docs: def compute(self):
          """
              This method can be used for computing one MaxSAT solution,
              i.e. for computing an assignment satisfying all hard
              clauses of the input formula and maximizing the sum of
              weights of satisfied soft clauses. It is a wrapper for the
              internal :func:`compute_` method, which does the job,
              followed by the model extraction.
  
              Note that the method returns ``None`` if no MaxSAT model
              exists. The method can be called multiple times, each
              being followed by blocking the last model. This way one
              can enumerate top-:math:`k` MaxSAT solutions (this can
              also be done by calling :meth:`enumerate()`).
  
              :returns: a MaxSAT model
              :rtype: list(int)
  
              .. code-block:: python
  
                  >>> from pysat.examples.rc2 import RC2
                  >>> from pysat.formula import WCNF
                  >>>
                  >>> rc2 = RC2(WCNF())  # passing an empty WCNF() formula
                  >>> rc2.add_clause([-1, -2])
                  >>> rc2.add_clause([-1, -3])
                  >>> rc2.add_clause([-2, -3])
                  >>>
                  >>> rc2.add_clause([1], weight=1)
                  >>> rc2.add_clause([2], weight=1)
                  >>> rc2.add_clause([3], weight=1)
                  >>>
                  >>> model = rc2.compute()
                  >>> print model
                  [-1, -2, 3]
                  >>> print rc2.cost
                  2
                  >>> rc2.delete()
          """
  
          # simply apply MaxSAT only once
          res = self.compute_()
  
          if res:
              # 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