docs: def _compute_bg_from_ll(self):
          """
          m._compute_bg_from_ll()
  
          Compute background model from log-likelihood matrix
          by noting that:   pA  + pT  + pC  + pG  = 1
                    and     bgA + bgT + bgC + bgG = 1
                    and     bgA = bgT,   bgC = bgG
                    and so  bgA = 0.5 - bgC
                    and     pA  = lA * bgA,  etc for T, C, G
                    so...
                           (lA + lT)bgA + (lC + lG)bgC          =  1
                           (lA + lT)bgA + (lC + lG)(0.5 - bgA)  =  1
                           (lA + lT - lC - lG)bgA +(lC +lG)*0.5 =  1
                            bgA                                 =  {1 - 0.5(lC + lG)} / (lA + lT - lC - lG)
          + Gain accuracy by taking average of bgA over all positions of PSSM
          """
          
          pow = math.pow
          bgATtot = 0
          nocount = 0
          near0   = lambda x:(-0.01 < x and x < 0.01)
          for i in range(self.width):
              _D = self.ll[i]
              ATtot = pow(2,_D['A']) + pow(2,_D['T'])
              GCtot = pow(2,_D['C']) + pow(2,_D['G'])
              if near0(_D['A']) and near0(_D['T']) and near0(_D['G']) and near0(_D['C']):
                  nocount = nocount + 1
                  continue
              if near0(ATtot-GCtot):     #Kludge to deal with indeterminate case
                  nocount = nocount + 1
                  continue
              bgAT   = (1.0 - 0.5*GCtot)/(ATtot - GCtot)
              if (bgAT < 0.1) or (bgAT > 1.1):
                  nocount = nocount + 1
                  continue
              bgATtot = bgATtot + bgAT
          if nocount == self.width:  #Kludge to deal with different indeterminate case
              self.background = {'A':0.25, 'C':0.25, 'G':0.25, 'T':0.25}
              return
          bgAT = bgATtot / (self.width - nocount)
          bgGC = 0.5 - bgAT
          self.background = {'A':bgAT, 'C':bgGC, 'G':bgGC, 'T':bgAT}