nodes: 0, module; 1, function_definition; 2, function_name:argsort; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, return_statement; 13, identifier:axis; 14, unary_operator; 15, identifier:kind; 16, string; 17, identifier:order; 18, None; 19, comment:"""
          Returns the indices that would sort an array.
  
          .. note::
  
                  This method wraps `numpy.argsort`.  This documentation is 
                  modified from that of `numpy.argsort`.
  
          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 the original array that index data along the given axis 
          in sorted order.
  
          **Parameters**
  
                  **axis** : int or None, optional
  
                          Axis along which to sort.  The default is -1 (the last 
                          axis). If `None`, the flattened array is used.
  
                  **kind** : {'quicksort', 'mergesort', 'heapsort'}, optional
  
                          Sorting algorithm.
  
                  **order** : list, optional
  
                          This argument specifies which fields to compare first, 
                          second, etc.  Not all fields need be specified.
  
          **Returns**
  
                  **index_array** : ndarray, int
  
                          Array of indices that sort the tabarray along the 
                          specified axis.  In other words, ``a[index_array]`` 
                          yields a sorted `a`.
  
                  **See Also**
  
                          sort : Describes sorting algorithms used.
                          lexsort : Indirect stable sort with multiple keys.
                          ndarray.sort : Inplace sort.
  
                  **Notes**
  
                          See `numpy.sort` for notes on the different sorting 
                          algorithms.
  
                  **Examples**
  
                          Sorting with keys:
  
                          >>> x = tabarray([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
                          >>> x
                          tabarray([(1, 0), (0, 1)], 
                                dtype=[('x', '<i4'), ('y', '<i4')])
  
                          >>> x.argsort(order=('x','y'))
                          array([1, 0])
  
                          >>> x.argsort(order=('y','x'))
                          array([0, 1])
  
          """; 20, assignment; 21, assignment; 22, identifier:index_array; 23, integer:1; 24, string_content:quicksort; 25, identifier:index_array; 26, call; 27, identifier:index_array; 28, call; 29, attribute; 30, argument_list; 31, attribute; 32, argument_list; 33, attribute; 34, identifier:_wrapit; 35, identifier:self; 36, string; 37, identifier:axis; 38, identifier:kind; 39, identifier:order; 40, identifier:index_array; 41, identifier:view; 42, attribute; 43, attribute; 44, identifier:fromnumeric; 45, string_content:argsort; 46, identifier:np; 47, identifier:ndarray; 48, identifier:np; 49, identifier:core
code: def argsort(self, axis=-1, kind='quicksort', order=None):
          """
          Returns the indices that would sort an array.
  
          .. note::
  
                  This method wraps `numpy.argsort`.  This documentation is 
                  modified from that of `numpy.argsort`.
  
          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 the original array that index data along the given axis 
          in sorted order.
  
          **Parameters**
  
                  **axis** : int or None, optional
  
                          Axis along which to sort.  The default is -1 (the last 
                          axis). If `None`, the flattened array is used.
  
                  **kind** : {'quicksort', 'mergesort', 'heapsort'}, optional
  
                          Sorting algorithm.
  
                  **order** : list, optional
  
                          This argument specifies which fields to compare first, 
                          second, etc.  Not all fields need be specified.
  
          **Returns**
  
                  **index_array** : ndarray, int
  
                          Array of indices that sort the tabarray along the 
                          specified axis.  In other words, ``a[index_array]`` 
                          yields a sorted `a`.
  
                  **See Also**
  
                          sort : Describes sorting algorithms used.
                          lexsort : Indirect stable sort with multiple keys.
                          ndarray.sort : Inplace sort.
  
                  **Notes**
  
                          See `numpy.sort` for notes on the different sorting 
                          algorithms.
  
                  **Examples**
  
                          Sorting with keys:
  
                          >>> x = tabarray([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
                          >>> x
                          tabarray([(1, 0), (0, 1)], 
                                dtype=[('x', '<i4'), ('y', '<i4')])
  
                          >>> x.argsort(order=('x','y'))
                          array([1, 0])
  
                          >>> x.argsort(order=('y','x'))
                          array([0, 1])
  
          """
          index_array = np.core.fromnumeric._wrapit(self, 'argsort', axis, 
                                                       kind, order)
          index_array = index_array.view(np.ndarray)
          return index_array