processPreRow() [2/2]

void NCF4::processPreRow ( PreRow r, RowsVector & rowsVector, MemoryBlock & memoryBlock, PreRowFeeder * feeder )

private

Definition at line 583 of file NCF4.cpp.

{
  // note: left and right should be the empty word if gbIndex < 0 indicating
  // an input polynomial.
  Word left = r.left;
  int gbIndex = r.preRowIndex;
  Word right = r.right;
  PreRowType preRowType = r.preRowType;
  
  if (M2_gbTrace >= 100) 
    std::cout << "Processing PreRow: ("
              << left << "," << gbIndex << "," << right << ")"
              << std::endl;
 
  // construct the elem corresponding to this prerow
  // it will either be:
  //  a multiple of a previously reduced row (if prevReducer)
  //  an element of the input (if gbIndex < 0 and not prevReducer)
  //  a multiple of a gb element (if gbIndex >= 0 and not prevReducer)
  const Poly* elem;
  Poly* tempelem;
  if (preRowType == PreviousReducerPreRow)
  {
    // in this case, we construct the poly locally for processing in this
    // function.  We will destroy it at the end, as the new monomials for reduction
    // are created and inserted into mMonomialSpace
    tempelem = new Poly;
    reducedRowToPoly(tempelem,mPreviousRows,mPreviousColumns,gbIndex);
    elem = tempelem;
  }
  else
  {
    if (gbIndex < 0)
      elem = mInput[-gbIndex-1];
    else
      elem = mGroebner[gbIndex];
  }
  
  // loop through all monomials of the product
  // for each monomial:
  //  (the below steps are now in processMonomInPreRow)
  //  is its prefix or suffix the lead term of a row from the previous degree?
  //    if so: insert the information from this row in the appropriate places
  //    if not: is the monomial in the hash table?
  //      if so: return the column index into the component for the new row.
  //      if not: insert it, and return the new column index into same place
  //          and place this monomial into mColumns.
  //          and search for divisor for it.
  //        
  int numTerms = elem->numTerms();
 
  auto wordRange = memoryBlock.allocateArray<Word>(numTerms);
  auto columnRange = memoryBlock.allocateArray<int>(numTerms);
  // int* componentAlloc = (int*)mMemoryPool.malloc(numTerms*sizeof(int));
  // Range<int> componentRange(componentAlloc,componentAlloc + numTerms);
  // for (auto& i : componentRange) i = 0;
 
  Word* nextColWord = wordRange.first;
 
  for (auto i = elem->cbegin(); i != elem->cend(); ++i)
  {
    Word mid;
    freeAlgebra().monoid().wordFromMonom(mid,i.monom());
    Word w = freeAlgebra().monoid().wordProductAsWord(left,mid,right,memoryBlock);
    processWordInPreRow(w,feeder);
    *nextColWord = w;
    ++nextColWord;
  }
 
  // this memory is stored in rowsVector and cleaned up later.
  ElementArray coeffs = mVectorArithmetic->elementArrayFromContainer(elem->getElementArray());
 
  // delete the Poly created for prevReducer case, if necessary.
  if (preRowType == PreviousReducerPreRow)
  {
    mFreeAlgebra.clear(*tempelem);
    delete tempelem;
  }
 
  // add the processed row to the appropriate list
  rowsVector.emplace_back(Row {coeffs, columnRange, wordRange});
}

References MemoryBlock::allocateArray(), freeAlgebra(), NCF4::PreRow::left, M2_gbTrace, mFreeAlgebra, mGroebner, mInput, FreeAlgebra::monoid(), mPreviousColumns, mPreviousRows, mVectorArithmetic, NCF4::PreRow::preRowIndex, NCF4::PreRow::preRowType, PreviousReducerPreRow, processWordInPreRow(), reducedRowToPoly(), NCF4::PreRow::right, FreeMonoid::wordFromMonom(), and FreeMonoid::wordProductAsWord().

Referenced by buildF4Matrix(), parallelBuildF4Matrix(), and processPreRow().