void F4Res::construct(int lev, int degree)
{
decltype(timer()) timeA, timeB;
resetMatrix(lev, degree);
timeA = timer();
makeMatrix();
timeB = timer();
mFrame.timeMakeMatrix += seconds(timeB - timeA);
if (M2_gbTrace >= 2) mHashTable.dump();
if (M2_gbTrace >= 2)
std::cout << " make matrix time: " << seconds(timeB - timeA) << " sec"
<< std::endl;
#if 0
std::cout << "-- rows --" << std::endl;
debugOutputReducers();
std::cout << "-- columns --" << std::endl;
debugOutputColumns();
std :: cout << "-- reducer matrix --" << std::endl;
if (true or lev <= 2)
debugOutputMatrix(mReducers);
else
debugOutputMatrixSparse(mReducers);
std :: cout << "-- reducer matrix --" << std::endl;
debugOutputMatrix(mReducers);
debugOutputMatrixSparse(mReducers);
std :: cout << "-- spair matrix --" << std::endl;
debugOutputMatrix(mSPairs);
debugOutputMatrixSparse(mSPairs);
#endif
if (M2_gbTrace >= 2)
std::cout << " (degree,level)=(" << (mThisDegree - mThisLevel) << ","
<< mThisLevel << ") #spairs=" << mSPairs.size()
<< " reducer= " << mReducers.size() << " x " << mReducers.size()
<< std::endl;
if (M2_gbTrace >= 2) std::cout << " gauss reduce matrix" << std::endl;
timeA = timer();
gaussReduce();
timeB = timer();
mFrame.timeGaussMatrix += seconds(timeB - timeA);
if (M2_gbTrace >= 2)
std::cout << " time: " << seconds(timeB - timeA) << " sec" << std::endl;
// mFrame.show(-1);
timeA = timer();
clearMatrix();
timeB = timer();
mFrame.timeClearMatrix += seconds(timeB - timeA);
}
void F4Res::makeMatrix()
{
// std::cout << "entering makeMatrix()" << std::endl;
auto& myframe = mFrame.level(mThisLevel);
long r = 0;
long comp = 0;
for (auto it = myframe.begin(); it != myframe.end(); ++it)
{
if (it->mDegree == mThisDegree)
{
mSPairs.push_back(Row());
mSPairComponents.push_back(comp);
Row& row = mSPairs[r];
r++;
row.mLeadTerm = it->mMonom;
loadRow(row);
if (M2_gbTrace >= 4)
if (r % 5000 == 0)
std::cout << "makeMatrix sp: " << r
<< " #rows = " << mColumns.size() << std::endl;
}
comp++;
}
// Now we process all monomials in the columns array
while (mNextReducerToProcess < mColumns.size())
{
// Warning: mReducers is being appended to during 'loadRow', and
// since we act on the Row directly, it might get moved on us!
// (actually, it did get moved, which prompted this fix)
Row thisrow;
std::swap(mReducers[mNextReducerToProcess], thisrow);
loadRow(thisrow);
std::swap(mReducers[mNextReducerToProcess], thisrow);
mNextReducerToProcess++;
if (M2_gbTrace >= 4)
if (mNextReducerToProcess % 5000 == 0)
std::cout << "makeMatrix red: " << mNextReducerToProcess
<< " #rows = " << mReducers.size() << std::endl;
}
reorderColumns();
#if 0
debugOutputReducers();
debugOutputColumns();
std :: cout << "-- reducer matrix --" << std::endl;
debugOutputMatrix(mReducers);
debugOutputMatrixSparse(mReducers);
std :: cout << "-- spair matrix --" << std::endl;
debugOutputMatrix(mSPairs);
debugOutputMatrixSparse(mSPairs);
#endif
}
void F4Res::reorderColumns()
{
// Set up to sort the columns.
// Result is an array 0..ncols-1, giving the new order.
// Find the inverse of this permutation: place values into "ord" column fields.
// Loop through every element of the matrix, changing its comp array.
#if 0
std::cout << "-- rows --" << std::endl;
debugOutputReducers();
std::cout << "-- columns --" << std::endl;
debugOutputColumns();
std::cout << "reorderColumns" << std::endl;
#endif
ComponentIndex ncols = static_cast<ComponentIndex>(mColumns.size());
// sort the columns
auto timeA = timer();
ComponentIndex* column_order = new ComponentIndex[ncols];
ComponentIndex* ord = new ComponentIndex[ncols];
ResColumnsSorter C(monoid(), *this, mThisLevel-1);
C.reset_ncomparisons();
for (ComponentIndex i=0; i<ncols; i++)
{
column_order[i] = i;
}
if (M2_gbTrace >= 2)
fprintf(stderr, " ncomparisons = ");
std::sort(column_order, column_order+ncols, C);
auto timeB = timer();
mFrame.timeSortMatrix += seconds(timeB-timeA);
if (M2_gbTrace >= 2)
fprintf(stderr, "%ld, ", C.ncomparisons0());
if (M2_gbTrace >= 2)
std::cout << " sort time: " << seconds(timeB-timeA) << std::endl;
timeA = timer();
////////////////////////////
for (ComponentIndex i=0; i<ncols; i++)
{
ord[column_order[i]] = i;
}
#if 0
std::cout << "column_order: ";
for (ComponentIndex i=0; i<ncols; i++) std::cout << " " << column_order[i];
std::cout << std::endl;
std::cout << "ord: ";
for (ComponentIndex i=0; i<ncols; i++) std::cout << " " << ord[i];
std::cout << std::endl;
#endif
// Now move the columns into position
std::vector<packed_monomial> sortedColumnArray;
std::vector<Row> sortedRowArray;
sortedColumnArray.reserve(ncols);
sortedRowArray.reserve(ncols);
for (ComponentIndex i=0; i<ncols; i++)
{
ComponentIndex newc = column_order[i];
sortedColumnArray.push_back(mColumns[newc]);
sortedRowArray.push_back(Row());
std::swap(sortedRowArray[i], mReducers[newc]);
}
std::swap(mColumns, sortedColumnArray);
std::swap(mReducers, sortedRowArray);
#if 0
std::cout << "applying permutation to reducers" << std::endl;
#endif
for (ComponentIndex i=0; i<mReducers.size(); i++)
{
#if 0
std::cout << "reducer " << i << " before:";
for (ComponentIndex j=0; j<mReducers[i].mComponents.size(); j++) std::cout << " " << mReducers[i].mComponents[j];
std::cout << std::endl;
#endif
applyPermutation(ord, mReducers[i].mComponents);
#if 0
std::cout << "reducer " << i << " after:";
for (ComponentIndex j=0; j<mReducers[i].mComponents.size(); j++) std::cout << " " << mReducers[i].mComponents[j];
std::cout << std::endl;
#endif
}
#if 0
std::cout << "applying permutation to spairs" << std::endl;
#endif
for (ComponentIndex i=0; i<mSPairs.size(); i++)
{
#if 0
std::cout << "spair " << i << " before:";
for (ComponentIndex j=0; j<mSPairs[i].mComponents.size(); j++) std::cout << " " << mSPairs[i].mComponents[j];
std::cout << std::endl;
#endif
applyPermutation(ord, mSPairs[i].mComponents);
#if 0
std::cout << "spair " << i << " after:";
for (ComponentIndex j=0; j<mSPairs[i].mComponents.size(); j++) std::cout << " " << mSPairs[i].mComponents[j];
std::cout << std::endl;
#endif
}
timeB = timer();
mFrame.timeReorderMatrix += seconds(timeB-timeA);
delete [] column_order;
delete [] ord;
}
void F4Res::reorderColumns()
{
// Set up to sort the columns.
// Result is an array 0..ncols-1, giving the new order.
// Find the inverse of this permutation: place values into "ord" column fields.
// Loop through every element of the matrix, changing its comp array.
#if 0
std::cout << "-- rows --" << std::endl;
debugOutputReducers();
std::cout << "-- columns --" << std::endl;
debugOutputColumns();
std::cout << "reorderColumns" << std::endl;
#endif
ComponentIndex ncols = static_cast<ComponentIndex>(mColumns.size());
ComponentIndex* ord = new ComponentIndex[ncols];
auto timeA = timer();
ResMonomialSorter sorter(ring().originalMonoid(), monoid(), frame().schreyerOrder(mThisLevel-2), mColumns);
auto column_order = sorter.sort();
auto timeB = timer();
double nsec_sort2 = seconds(timeB - timeA);
mFrame.timeSortMatrix += nsec_sort2;
auto ncompares = sorter.numComparisons();
if (M2_gbTrace >= 2)
std::cout << " #comparisons sorting " << ncols << " columns = " << ncompares << " ";
if (M2_gbTrace >= 1)
std::cout << " sort time: " << nsec_sort2 << std::endl;
timeA = timer();
////////////////////////////
for (ComponentIndex i = 0; i < ncols; i++)
{
ord[column_order[i]] = i;
}
#if 0
std::cout << "column_order: ";
for (ComponentIndex i=0; i<ncols; i++) std::cout << " " << column_order[i];
std::cout << std::endl;
std::cout << "ord: ";
for (ComponentIndex i=0; i<ncols; i++) std::cout << " " << ord[i];
std::cout << std::endl;
#endif
// Now move the columns into position
std::vector<res_packed_monomial> sortedColumnArray;
std::vector<Row> sortedRowArray;
sortedColumnArray.reserve(ncols);
sortedRowArray.reserve(ncols);
for (ComponentIndex i = 0; i < ncols; i++)
{
ComponentIndex newc = column_order[i];
sortedColumnArray.push_back(mColumns[newc]);
sortedRowArray.push_back(Row());
std::swap(sortedRowArray[i], mReducers[newc]);
}
std::swap(mColumns, sortedColumnArray);
std::swap(mReducers, sortedRowArray);
#if 0
std::cout << "applying permutation to reducers" << std::endl;
#endif
for (ComponentIndex i = 0; i < mReducers.size(); i++)
{
#if 0
std::cout << "reducer " << i << " before:";
for (ComponentIndex j=0; j<mReducers[i].mComponents.size(); j++) std::cout << " " << mReducers[i].mComponents[j];
std::cout << std::endl;
#endif
applyPermutation(ord, mReducers[i].mComponents);
#if 0
std::cout << "reducer " << i << " after:";
for (ComponentIndex j=0; j<mReducers[i].mComponents.size(); j++) std::cout << " " << mReducers[i].mComponents[j];
std::cout << std::endl;
#endif
}
#if 0
std::cout << "applying permutation to spairs" << std::endl;
#endif
for (ComponentIndex i = 0; i < mSPairs.size(); i++)
{
#if 0
std::cout << "spair " << i << " before:";
for (ComponentIndex j=0; j<mSPairs[i].mComponents.size(); j++) std::cout << " " << mSPairs[i].mComponents[j];
std::cout << std::endl;
#endif
applyPermutation(ord, mSPairs[i].mComponents);
#if 0
std::cout << "spair " << i << " after:";
for (ComponentIndex j=0; j<mSPairs[i].mComponents.size(); j++) std::cout << " " << mSPairs[i].mComponents[j];
std::cout << std::endl;
#endif
}
timeB = timer();
mFrame.timeReorderMatrix += seconds(timeB - timeA);
delete[] ord;
}
