int maxLevel(mynode *node)
{
if(node != NULL)
return max(maxLevel(node->left),maxLevel(node->right)) + 1;
else
return 0;
}
AmrAdv::AmrAdv ()
{
ReadParameters();
// Geometry on all levels has been defined already.
// No valid BoxArray and DistributionMapping have been defined.
// But the arrays for them have been resized.
int nlevs_max = maxLevel() + 1;
istep.resize(nlevs_max, 0);
nsubsteps.resize(nlevs_max, 1);
for (int lev = 1; lev <= maxLevel(); ++lev) {
nsubsteps[lev] = MaxRefRatio(lev-1);
}
last_regrid_step.resize(nlevs_max, 0);
t_new.resize(nlevs_max, 0.0);
t_old.resize(nlevs_max, -1.e100);
dt.resize(nlevs_max, 1.e100);
phi_new.resize(nlevs_max);
phi_old.resize(nlevs_max);
flux_reg.resize(nlevs_max+1);
}
int diameter(Node* root) {
if(!root) {
return -1;
}
return std::max(
std::max(diameter(root->child[0]), diameter(root->child[1])),
1 + maxLevel(root->child[0]) + 1 + maxLevel(root->child[1]) + 1
);
}
void SchreyerFrame::computeSyzygies(int slanted_degree, int maxlevel)
{
// Compute everything up to this point
int toplevel = (maxlevel < maxLevel() ? maxlevel : maxLevel());
for (int deg = mLoSlantedDegree; deg <= slanted_degree; deg++)
for (int lev=2; lev<=toplevel; lev++)
{
fillinSyzygies(deg,lev);
}
}
void SchreyerFrame::computeRanks(int slanted_degree, int maxlevel)
{
// Compute all needed ranks to get the minimal Betti numbers in the range
// deg <= slanted_degree, lev <=maxlevel.
// This means: we need to compute ranks to level maxlevel+1 (or largest that exists)
// in degrees <= slanted_degree, EXCEPT we don't need to compute at (slanted_degree,maxlevel+1).
int toplevel = (maxlevel < maxLevel() ? maxlevel-1 : mMaxLength);
for (int deg=mLoSlantedDegree; deg <=slanted_degree; deg++)
for (int lev=1; lev<=toplevel; lev++)
computeRank(deg, lev);
}
bool SchreyerFrame::debugCheckOrderAll() const
{
std::cout << "checking that all input and constructed polynomials are in order...";
bool result = true;
for (auto i = 1; i<maxLevel(); ++i)
if (!debugCheckOrder(i))
result = false;
if (result)
std::cout << "ok" << std::endl;
return result;
}
int main(int argc,char **argv)
{
int i = 0;
mynode *root = NULL;
srand(time(NULL));
for(i=0;i<MAX_NODE;i++)
root = Insert(rand()%50+1,root);
Dump(root);
printf("\nmaxLevel = %d\n",maxLevel(root));
return 0;
}
M2_arrayint SchreyerFrame::getBetti(int type)
{
if (type == 4)
{
computeFrame();
decltype(timer()) timeA, timeB;
timeA = timer();
computeRanks(mHiSlantedDegree, maxLevel());
timeB = timer();
timeComputeRanks += seconds(timeB-timeA);
return mBettiMinimal.getBetti();
}
if (type == 0 or type == 1)
return getBettiFrame();
if (type == 5)
return mComputationStatus.getBetti();
ERROR("betti display not implemenented yet");
return 0;
}
plRenderLevel plMaxNodeBase::ICalcRenderLevel(hsBool forBlend)
{
if( GetBlendToFB() )
return plRenderLevel::kFBMajorLevel;
if( GetAvatarSO() )
return plRenderLevel(plRenderLevel::kOpaqueMajorLevel, plRenderLevel::kAvatarRendMinorLevel);
if( GetNoDeferDraw() )
forBlend = false;
int numDep = NumRenderDependencies();
if( !numDep )
return forBlend
? plRenderLevel(plRenderLevel::kBlendRendMajorLevel, plRenderLevel::kDefRendMinorLevel)
: plRenderLevel(plRenderLevel::kDefRendMajorLevel, plRenderLevel::kDefRendMinorLevel);
plRenderLevel maxLevel(plRenderLevel::kFBMajorLevel, plRenderLevel::kDefRendMinorLevel);
const char* dbgNodeName = GetName();
int i;
for( i = 0; i < numDep; i++ )
{
plMaxNodeBase* dep = GetRenderDependency(i);
if( dep )
{
const char* depNodeName = dep->GetName();
plRenderLevel depLev = GetRenderDependency(i)->GetRenderLevel(forBlend);
if( depLev > maxLevel )
maxLevel = depLev;
}
}
maxLevel.Set(maxLevel.Level() + 4);
return maxLevel;
}
int maxLevel(Node* root) {
if(!root) {
return -1;
}
return std::max(maxLevel(root->child[0]), maxLevel(root->child[1])) + 1;
}
int SchreyerFrame::rank(int slanted_degree, int lev)
{
// As above, get the size of the matrix, and 'newcols'
// Now we loop through the elements of degree 'slanted_degree + lev' at level 'lev'
if (not (lev > 0 and lev <= maxLevel())
and not (slanted_degree >= mLoSlantedDegree and slanted_degree < mHiSlantedDegree))
{
std::cerr << "ERROR: called rank(" << slanted_degree << "," << lev << ")" << std::endl;
return 0;
}
assert(lev > 0 and lev <= maxLevel());
assert(slanted_degree >= mLoSlantedDegree and slanted_degree < mHiSlantedDegree);
int degree = slanted_degree + lev;
auto& thislevel = level(lev);
int ncols = 0;
for (auto p=thislevel.begin(); p != thislevel.end(); ++p)
{
if (p->mDegree == degree) ncols++;
}
auto& prevlevel = level(lev-1);
int* newcomps = new int[prevlevel.size()];
int nrows = 0;
for (int i=0; i<prevlevel.size(); i++)
if (prevlevel[i].mDegree == degree)
newcomps[i] = nrows++;
else
newcomps[i] = -1;
// Create the ARing
// Create a DMat
// M2::ARingZZpFlint R(gausser().get_ring()->characteristic());
// DMat<M2::ARingZZpFlint> M(R, nrows, ncols);
#if 0
// TODO: Change this
M2::ARingZZpFFPACK R(gausser().get_ring()->characteristic());
DMat<M2::ARingZZpFFPACK> M(R, nrows, ncols);
#endif
// Fill in DMat
// loop through the elements at thislevel,
// and for each, loop through the terms of mSyzygy.
// if the component x satisfies newcomps[x] >= 0, then place
// this coeff into the mutable matrix.
int col = 0;
long nnonzeros = 0;
for (auto p=thislevel.begin(); p != thislevel.end(); ++p)
{
if (p->mDegree != degree) continue;
auto& f = p->mSyzygy;
auto end = poly_iter(ring(), f, 1);
auto i = poly_iter(ring(), f);
for ( ; i != end; ++i)
{
long comp = monoid().get_component(i.monomial());
if (newcomps[comp] >= 0)
{
#if 0
// TODO: change this line:
M.entry(newcomps[comp], col) = gausser().coeff_to_int(i.coefficient());
#endif
nnonzeros++;
}
}
++col;
}
double frac_nonzero = (nrows*ncols);
frac_nonzero = nnonzeros / frac_nonzero;
// buffer o;
// displayMat(o, M);
// std::cout << o.str() << std::endl;
// call rank
// auto a = DMatLinAlg<M2::ARingZZpFlint>(M);
#if 0
// TODO: change this line
auto a = DMatLinAlg<M2::ARingZZpFFPACK>(M);
long numrows = M.numRows();
long numcols = M.numColumns();
#endif
long numrows = 0;
long numcols = 0;
clock_t begin_time0 = clock();
int rk = 0; // TODO: static_cast<int>(a.rank());
clock_t end_time0 = clock();
double nsecs0 = (double)(end_time0 - begin_time0)/CLOCKS_PER_SEC;
if (M2_gbTrace >= 2)
{
std::cout << "rank (" << slanted_degree << "," << lev << ") = " << rk
<< " time " << nsecs0 << " size= " << numrows
<< " x " << numcols << " nonzero " << nnonzeros << std::endl;
}
return rk;
}
void SchreyerFrame::setBettiDisplays()
{
int lo, hi, len;
getBounds(lo, hi, len);
//std::cout << "bounds: lo=" << lo << " hi=" << hi << " len=" << len << std::endl;
mBettiNonminimal = BettiDisplay(lo,hi,len);
mBettiMinimal = BettiDisplay(lo,hi,len);
mComputationStatus = BettiDisplay(lo,hi,maxLevel());
for (int lev=0; lev<=len; lev++)
{
auto& myframe = level(lev);
for (auto p=myframe.begin(); p != myframe.end(); ++p)
{
int deg = p->mDegree; // this is actual degree, not slanted degree
mBettiNonminimal.entry(deg-lev,lev) ++ ;
mBettiMinimal.entry(deg-lev,lev) ++ ;
}
}
#if 0
// Now set the todo list of pairs (degree, level) for minimalization.
for (int slanted_degree = lo; slanted_degree < hi; slanted_degree++)
{
for (int lev = 1; lev <= maxLevel()-1; lev++)
{
if (mBettiNonminimal.entry(slanted_degree, lev) > 0 and mBettiNonminimal.entry(slanted_degree+1, lev-1) > 0)
{
mMinimalizeTODO.push_back(std::make_pair(slanted_degree, lev));
}
}
}
#endif
// Meaning: 0: no syzygies in that (degree,lev)
// 1: there are some, but syzygies have not been constructed yet
// 2: syzygies have been constructed
// 3: syzygies have been constructed AND rank from (deg,lev) to (deg+1,lev-1) has been
// computed, and the ranks taken into account in mMinimalBetti.
for (int slanted_degree = lo; slanted_degree <= hi; slanted_degree++)
{
if (len >= 0)
{
if (mBettiNonminimal.entry(slanted_degree, 0) == 0)
mComputationStatus.entry(slanted_degree, 0) = 0;
else
mComputationStatus.entry(slanted_degree, 0) = 3;
}
if (len >= 1)
{
if (mBettiNonminimal.entry(slanted_degree, 1) == 0)
mComputationStatus.entry(slanted_degree, 1) = 0;
else
mComputationStatus.entry(slanted_degree, 1) = 2;
}
for (int lev = 2; lev <= maxLevel(); lev++)
{
if ((lev > len) or mBettiNonminimal.entry(slanted_degree, lev) == 0)
mComputationStatus.entry(slanted_degree, lev) = 0;
else
mComputationStatus.entry(slanted_degree, lev) = 1;
}
}
}
BettiDisplay SchreyerFrame::minimalBettiNumbers(
bool stop_after_degree,
int top_slanted_degree,
int length_limit
)
{
// The lo degree will be: mLoSlantedDegree.
// The highest slanted degree will either be mHiSlantedDegree, or top_slanted_degree (minimum of these two).
// The length we need to compute to is either maxLevel(), or length_limit+1.
// We set maxlevel to length_limit. We insist that length_limit <= maxLevel() - 2.
// Here is what needs to be computed:
// lo: . . . . . . .
// . . . . . . .
/// hi: . . . . . .
// Each dot in all rows other than 'hi' needs to have syzygies computed for it.
// if hi == mHiSlantedDegree, then we do NOT need to compute syzygies in this last row.
// else we need to compute syzygies in these rows, EXCEPT not at level maxlevel+1
computeFrame();
int top_degree; // slanted degree
if (stop_after_degree)
{
top_degree = std::min(top_slanted_degree, mHiSlantedDegree);
top_degree = std::max(mLoSlantedDegree, top_degree);
}
else
{
top_degree = mHiSlantedDegree;
}
// First: if length_limit is too low, extend the Frame
if (length_limit >= maxLevel())
{
std::cout << "WARNING: cannot extend resolution length" << std::endl;
length_limit = maxLevel()-1;
// Extend the length of the Frame, change mMaxLength, possibly mHiSlantedDegree
// increase mComputationStatus if needed, mMinimalBetti, ...
// computeFrame()
}
// What needs to be computed?
// lodeg..hideg, level: 0..maxlevel. Note: need to compute at level maxlevel+1 in order to get min betti numbers at
// level maxlevel.
// Also note: if hideg is the highest degree that occurs in the frame, we do not need to compute any matrices for these.
for (int deg=mLoSlantedDegree; deg <= top_degree-1; deg++)
for (int lev=1; lev<=length_limit+1; lev++)
computeRank(deg, lev);
for (int lev=1; lev<=length_limit; lev++)
computeRank(top_degree, lev);
if (M2_gbTrace >= 1)
{
showMemoryUsage();
std::cout << "total setPoly: " << poly_constructor::ncalls << std::endl;
std::cout << "total setPolyFromArray: " << poly_constructor::ncalls_fromarray << std::endl;
std::cout << "total ~poly: " << poly::npoly_destructor << std::endl;
std::cout << "total time for make matrix: " << timeMakeMatrix << std::endl;
std::cout << "total time for sort matrix: " << timeSortMatrix << std::endl;
std::cout << "total time for reorder matrix: " << timeReorderMatrix << std::endl;
std::cout << "total time for gauss matrix: " << timeGaussMatrix << std::endl;
std::cout << "total time for clear matrix: " << timeClearMatrix << std::endl;
std::cout << "total time for reset hash table: " << timeResetHashTable << std::endl;
std::cout << "total time for computing ranks: " << timeComputeRanks << std::endl;
}
BettiDisplay B(mBettiMinimal); // copy
B.resize(mLoSlantedDegree,
top_degree,
length_limit);
return B;
}
