docs: def slow_reduction_transfer(ii, j, idx, count, x, u, v, c):
      '''Perform the reduction transfer step from the Jonker-Volgenant algorithm
      
      The data is input in a ragged array in terms of "i" structured as a
      vector of values for each i,j combination where:
      
      ii - the i to be reduced
      j - the j-index of every entry
      idx - the index of the first entry for each i
      count - the number of entries for each i
      x - the assignment of j to i
      u - the dual variable "u" which will be updated. It should be
          initialized to zero for the first reduction transfer.
      v - the dual variable "v" which will be reduced in-place
      c - the cost for each entry.
      
      The code described in the paper is:
      
      for each assigned row i do
      begin
         j1:=x[i]; u=min {c[i,j]-v[j] | j=1..n, j != j1};
         v[j1]:=v[j1]-(u-u[i]);
         u[i] = u;
      end;
      
      The authors note that reduction transfer can be applied in later stages
      of the algorithm but does not seem to provide a substantial benefit
      in speed.
      '''
      for i in ii:
          j1 = x[i]
          jj = j[idx[i]:(idx[i]+count[i])]
          uu = np.min((c[idx[i]:(idx[i]+count[i])] - v[jj])[jj != j1])
          v[j1] = v[j1] - uu + u[i]
          u[i] = uu