gaussReduceRow()

void F4Res::gaussReduceRow ( int index, ElementArray & dense, bool onlyConstantMaps, const std::vector< bool > & track )

private

Definition at line 465 of file res-f4.cpp.

{   
  int i = index;
 
#ifdef DEBUG_GAUSS
      std::cout << "reducing row " << i << std::endl;
#endif
 
  // Reduce spair #i
  // fill in dense row with this element.
 
  ResPolynomialConstructor result(mRing);
 
  Row& r = mSPairs[i];  // row to be reduced.
  long comp = mSPairComponents[i];
  result.appendMonicTerm(mFrame.level(mThisLevel)[comp].mMonom);
 
  auto& syz = mFrame.level(mThisLevel)[comp].mSyzygy;  // this is the element we will fill out
 
  // Note: in the polynomial ring case, the row r is non-zero.
  // BUT: for skew commuting variables, it can happen that r is zero
  // (e.g. a.(acd<0>) = 0).  In this case we have nothing to reduce.
  if (!r.mComponents.empty())
    {
      ComponentIndex firstcol = r.mComponents[0];
      ComponentIndex lastcol = static_cast<ComponentIndex>(mColumns.size() - 1);  // maybe: r.mComponents[r.mComponents.size()-1];
 
#ifdef DEBUG_GAUSS
          std::cout << "about to fill from sparse " << i << std::endl;
#endif
 
      mRing.vectorArithmetic().fillDenseArray(gauss_row,
                                              r.mCoeffs,
                                              Range(&r.mComponents[0],
                                                    &r.mComponents[0] + static_cast<ComponentIndex>(r.mComponents.size())));
 
      while (firstcol <= lastcol)
        {
#ifdef DEBUG_GAUSS
              std::cout << "about to reduce with col " << firstcol << std::endl;
              std::cout << "gauss_row: "
                        << (gauss_row.isNull() ? "null" : "not-null")
                        << std::endl;
              std::cout << "mReducers[" << firstcol << "]: "
                        << (mReducers[firstcol].mCoeffs.isNull() ? "null"
                                                                 : "not-null")
                        << std::endl;
              std::cout << "result: " << (result.coefficientInserter().isNull()
                                              ? "null"
                                              : "not-null")
                        << std::endl;
              std::cout << "  dense: ";
              mRing.vectorArithmetic().displayElementArray(std::cout, gauss_row)
                  << std::endl;
              mRing.vectorArithmetic().displayElementArray(std::cout,
                                              mReducers[firstcol].mCoeffs);
              std::cout << std::endl;
              mRing.vectorArithmetic().displayElementArray(std::cout,
                                              result.coefficientInserter());
              std::cout << std::endl;
#endif
 
          if (onlyConstantMaps and not track[firstcol])
            {
              mRing.vectorArithmetic().denseCancelFromSparse(gauss_row,
                                                             mReducers[firstcol].mCoeffs,
                                                             Range(mReducers[firstcol].mComponents.data(),
                                                                   mReducers[firstcol].mComponents.data() +
                                                                   mRing.vectorArithmetic().size(mReducers[firstcol].mCoeffs)));
            }
          else
            {
              mRing.vectorArithmetic().denseCancelFromSparse(gauss_row,
                                                             mReducers[firstcol].mCoeffs,
                                                             Range(mReducers[firstcol].mComponents.data(),
                                                                   mReducers[firstcol].mComponents.data() +
                                                                   mRing.vectorArithmetic().size(mReducers[firstcol].mCoeffs)),
                                                             result.coefficientInserter());
 
#ifdef DEBUG_GAUSS
                  std::cout << "  done with sparseCancel" << std::endl;
                  mRing.vectorArithmetic().displayElementArray(std::cout, gauss_row)
                     << std::endl;
                  mRing.vectorArithmetic().displayElementArray(std::cout,
                                                  mReducers[firstcol].mCoeffs)
                      << std::endl;
                  mRing.vectorArithmetic().displayElementArray(std::cout,
                                                  result.coefficientInserter())
                      << std::endl;
                  std::cout << "  about to push back term" << std::endl;
#endif
              
              result.pushBackTerm(mReducers[firstcol].mLeadTerm);
 
#ifdef DEBUG_GAUSS
                  std::cout << "done with col " << firstcol << std::endl;
#endif
            }
          firstcol = mRing.vectorArithmetic().denseNextNonzero(gauss_row, firstcol + 1, lastcol);
        }
    }
 
#ifdef DEBUG_GAUSS
      std::cout << "about to set syz" << std::endl;
#endif
      result.setPoly(syz);
#ifdef DEBUG_GAUSS
      std::cout << "just set syz" << std::endl;
#endif
}

References ElementArray::isNull(), F4Res::Row::mCoeffs, mColumns, F4Res::Row::mComponents, mFrame, mReducers, mRing, mSPairComponents, mSPairs, mThisLevel, and result().

Referenced by gaussReduce().