code: def hard_limit_remote(self,
                            yidx,
                            ridx,
                            rtype='y',
                            rmin=None,
                            rmax=None,
                            min_yset=0,
                            max_yset=0):
          
          ny = len(yidx)
          assert ny == len(
              ridx), "Length of output vars and remote vars does not match"
          assert rtype in ('x',
                           'y'), "ridx must be either y (algeb) or x (state)"
  
          if isinstance(min_yset, (int, float)):
              min_yset = matrix(min_yset, (ny, 1), 'd')
          if isinstance(max_yset, (int, float)):
              max_yset = matrix(max_yset, (ny, 1), 'd')
  
          above_idx, below_idx = list(), list()
          yidx = matrix(yidx)
  
          if rmax:
              # find the over-limit remote idx
              above = ageb(self.__dict__[rtype][ridx], rmax)
              above_idx = index(above, 1.0)
              # reset the y values based on the remote limit violations
              self.y[yidx[above_idx]] = max_yset[above_idx]
              self.zymax[yidx[above_idx]] = 0
  
          if rmin:
              below = aleb(self.__dict__[rtype][ridx], rmin)
              below_idx = index(below, 1.0)
              self.y[yidx[below_idx]] = min_yset[below_idx]
              self.zymin[yidx[below_idx]] = 0
  
          idx = above_idx + below_idx
          self.g[yidx[idx]] = 0
  
          if len(idx) > 0:
              self.factorize = True
docs: Limit the output of yidx if the remote y is not within the limits
  
          This function needs to be modernized.