docs: def compute(self):
          """
              This method solves the MaxSAT problem iteratively. Each
              optimization level is tackled the standard way, i.e. by
              calling :func:`compute_`. A new level is started by
              calling :func:`next_level` and finished by calling
              :func:`finish_level`. Each new optimization level
              activates more soft clauses by invoking
              :func:`activate_clauses`.
          """
  
          done = 0  # levels done
  
          # first attempt to get an optimization level
          self.next_level()
  
          while self.levl != None and done < len(self.blop):
              # add more clauses
              done = self.activate_clauses(done)
  
              if self.verbose > 1:
                  print('c wght str:', self.blop[self.levl])
  
              # call RC2
              if self.compute_() == False:
                  return
  
              # updating the list of distinct weight levels
              self.blop = sorted([w for w in self.wstr], reverse=True)
  
              if done < len(self.blop):
                  if self.verbose > 1:
                      print('c curr opt:', self.cost)
  
                  # done with this level
                  self.finish_level()
  
                  self.levl += 1
  
                  # get another level
                  self.next_level()
  
                  if self.verbose > 1:
                      print('c')
  
          # extracting a model
          self.model = self.oracle.get_model()
          self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
          self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
          self.model = sorted(self.model, key=lambda l: abs(l))
  
          return self.model