preRowsFromOverlap()

void NCF4::preRowsFromOverlap ( const Overlap & o )

private

Definition at line 393 of file NCF4.cpp.

{
  // o = (gbLeftIndex, overLapPos, gbRightIndex).
  // BUT: if overlapPos < 0, then gbRightIndex is also < 0 (and is ignored), and gbLeftIndex
  //   refers to a generator, and we add to mOverlapsTodo in only (1,gbLeftIndex,1).
  // where 1 = empty word.
 
  int gbLeftIndex = std::get<0>(o);
  int overlapPos = std::get<1>(o);
  int gbRightIndex = std::get<2>(o);
 
  if (overlapPos < 0)
    {
      // Sneaky trick: a PreRow with index a < 0 refers to generator with index -a-1
      mOverlapsTodo.emplace_back(PreRow {Word(),
                                         - gbLeftIndex - 1,
                                         Word(),
                                         OverlapPreRow});
      return;
    }
  
  // LM(gbLeft) = x^a x^b
  // LM(gbRight) = x^b x^c
  // overlapPos = starting position of x^b in gbLeft.
  // one prerow will be: (1, gbLeftIndex, x^c)
  // another prerow will be: (x^a, gbRightIndex, 1)
      
  Word leadWordLeft = mWordTable[gbLeftIndex];
  Word leadWordRight = mWordTable[gbRightIndex];
  int overlapLen = leadWordLeft.size() - overlapPos;
 
  Word suffix2 {}; // trivial word
  Word prefix2(leadWordLeft.begin(), leadWordLeft.begin() + overlapPos);
  
  Word suffix1(leadWordRight.begin() + overlapLen, leadWordRight.end());
  Word prefix1 {}; // trivial word
  
  // need to add in the lead monomial to the mColumnMonomials list now
  // so they know which row reduces them
  Word newWord = freeAlgebra().monoid().wordProductAsWord(leadWordLeft, suffix1, mMonomialSpace);
 
  // This overlap may already have lead term in table.
  // Only have to add it in if it is not yet present.
  auto it = mColumnMonomials.find(newWord);
  if (it == mColumnMonomials.cend())
    mColumnMonomials.emplace(newWord, std::make_pair(-1,-1));
 
  // it *matters* which one is a reducer and which one is an overlap.
  // this is due to how the word table lookup works -- it searches them
  // in the order that they were entered into the word table, which may
  // not be sorted in term order.
  if (gbLeftIndex > gbRightIndex)
    {
      mReducersTodo.emplace_back(PreRow {prefix2,
                                         gbRightIndex,
                                         suffix2,
                                         ReducerPreRow});
      mOverlapsTodo.emplace_back(PreRow {prefix1,
                                         gbLeftIndex,
                                         suffix1,
                                         OverlapPreRow});
    }
  else
    {  
      mReducersTodo.emplace_back(PreRow {prefix1,
                                         gbLeftIndex,
                                         suffix1,
                                         ReducerPreRow});
      mOverlapsTodo.emplace_back(PreRow {prefix2,
                                         gbRightIndex,
                                         suffix2,
                                         OverlapPreRow});
    }
}

References Word::begin(), Word::end(), freeAlgebra(), mColumnMonomials, mMonomialSpace, FreeAlgebra::monoid(), mOverlapsTodo, mReducersTodo, mWordTable, OverlapPreRow, ReducerPreRow, Word::size(), and FreeMonoid::wordProductAsWord().

Referenced by buildF4Matrix(), and parallelBuildF4Matrix().