code: def argsort(self, axis=-1, kind='quicksort', order=None):
          
          index_array = np.core.fromnumeric._wrapit(self, 'argsort', axis, 
                                                       kind, order)
          index_array = index_array.view(np.ndarray)
          return index_array
docs: 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])