78 typedef std::stack <sBucket_pt>
Base;
91 push ( _CreateBucket(r) );
99 _DestroyBucket( top() );
104 Bucket
getBucket(
const ring r,
const bool remove =
true)
119 bt = _CreateBucket(r);
129 assume( _IsBucketEmpty(bt) );
130 assume( r == _GetBucketRing(bt) );
136 void putBucket(
const Bucket & bt,
const bool replace =
false)
139 assume( _IsBucketEmpty(bt) );
140 assume( m_ring == _GetBucketRing(bt) );
164 static ring _GetBucketRing(
const Bucket& bt);
166 static bool _IsBucketEmpty(
const Bucket& bt);
170 static Bucket _CreateBucket(
const ring r);
174 static void _DestroyBucket(Bucket & bt);
252 bool Check(
const poly m)
const;
271 bool DivisibilityCheck(
const poly multiplier,
const poly t,
const unsigned long not_sev,
const ring r)
const;
273 bool DivisibilityCheck(
const poly product,
const unsigned long not_sev,
const ring r)
const;
275 bool CheckLT(
const ideal & L )
const;
279 unsigned long sev()
const;
280 unsigned int label()
const;
283 inline unsigned long sev()
const {
return m_sev; };
284 inline unsigned int label()
const {
return m_label; };
288 const unsigned long m_sev;
298 const poly m_lt_copy;
327 void Initialize(
const ideal L);
341 bool IsDivisible(
const poly q)
const;
350 void DebugPrint()
const;
380 inline bool operator() (
const TCacheKey&
l,
const TCacheKey& r)
const {
assume(m_ring !=
NULL);
return my_p_LmCmp(l, r, m_ring); }
383 typedef std::map<TCacheKey, TCacheValue, CCacheCompare>
TP2PCache;
408 m_LS(
NULL), m_lcm(m_idLeads, setting),
409 m_div(m_idLeads, setting), m_checker(
NULL, setting), m_cache(),
420 m_syzLeads(syzLeads), m_syzTails(
NULL),
421 m_LS(syzLeads), m_lcm(m_idLeads, setting),
422 m_div(m_idLeads, setting), m_checker(
NULL, setting), m_cache(),
430 if (syzLeads !=
NULL)
431 m_checker.Initialize(syzLeads);
442 void SetUpTailTerms();
445 void PrintStats()
const;
451 syzL = m_syzLeads; syzT = m_syzTails;
453 m_syzLeads = m_syzTails =
NULL;
487 poly ComputeImage(
poly multiplier,
const int tail)
const;
494 {
return m_div.FindReducer(product, syzterm, m_checker); }
501 ideal Compute1LeadingSyzygyTerms();
571 mutable unsigned long m_stat[9];
619 return syz.
ReduceTerm(multiplier, term4reduction, syztermCheck);
Computation attribute storage.
CCacheCompare(const ring &r)
SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const ideal syzLeads, const SchreyerSyzygyComputationFlags setting)
Construct a global object for given input data (separated into leads & tails)
const unsigned int m_label
index in the main L[] + 1
int OPT__SYZNUMBER
Syzygy level (within a resolution)
std::stack< sBucket_pt > Base
CCacheCompare(const CCacheCompare &lhs)
ideal m_syzLeads
output (syzygy) leading terms (+2nd terms?)
poly SchreyerSyzygyNF(const poly syz_lead, poly syz_2=NULL) const
Main HybridNF == 1: poly reduce + LOT + LCM?
const int OPT__HYBRIDNF
Use the usual NF's S-poly reduction while dropping lower order terms 2 means - smart selection! ...
const int OPT__SYZCHECK
CheckSyzygyProperty: TODO.
const ideal m_idLeads
input leading terms
SBucketFactory(const ring r)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
void nextSyzygyLayer() const
const poly m_lt
the leading term itself L[label-1]
std::vector< const CLeadingTerm * > TReducers
ideal m_LS
leading syzygy terms used for reducing syzygy tails
unsigned long sev() const
ideal m_syzTails
output (syzygy) tails
#define UNLIKELY(expression)
#define LIKELY(expression)
kBucket_pt m_spoly_bucket
for S-Polynomial reductions
const int OPT__DEBUG
output all the intermediate states
CReducerFinder m_checker
for checking tail-terms and makeing them irreducible (wrt m_LS!)
~SchreyerSyzygyComputation()
Destructor should not destruct the resulting m_syzLeads, m_syzTails.
#define BEGIN_NAMESPACE_SINGULARXX
Bucket getBucket(const ring r, const bool remove=true)
poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck) const
TODO: save shortcut (syz: |-.->) LM(m) * "t" -> ? ???
const int OPT__TAILREDSYZ
Reduce syzygy tails wrt the leading syzygy terms.
void ComputeSyzygy()
The main driver function: computes.
#define END_NAMESPACE_SINGULARXX
const bool OPT__PROT
TEST_OPT_PROT.
poly TraverseTail(poly multiplier, const int tail) const
High level caching function!!!
void ComputeLeadingSyzygyTerms(bool bComputeSecondTerms=true)
Computes Syz(leads) or only LEAD of it. The result is stored into m_syzLeads.
const CReducerFinder m_div
Divisor finder.
void ReadOffResult(ideal &syzL, ideal &syzT)
Read off the results while detaching them from this object NOTE: no copy!
const unsigned int m_N
number of ring variables
const unsigned long m_sev
not short exp. vector
poly _FindReducer(const poly product, const poly syzterm) const
just for testing via the wrapper below
std::map< TComponentKey, TReducers > CReducersHash
The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it...
SchreyerSyzygyComputationFlags(idhdl rootRingHdl)
const int OPT__TREEOUTPUT
output lifting tree
const ring m_rBaseRing
global base ring
SBucketFactory m_sum_bucket_factory
TODO: look into m_idTailTerms!!!!!!!!!!!!!!!!!!!!!!!! map? heaps???
void putBucket(const Bucket &bt, const bool replace=false)
SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const SchreyerSyzygyComputationFlags setting)
Construct a global object for given input data (separated into leads & tails)
const int OPT__IGNORETAILS
ignore tails and compute the pure Schreyer frame
CCacheCompare & operator=(const CCacheCompare &lhs)
const CLCM m_lcm
Bitmask for variables occuring in leading terms.
SchreyerSyzygyComputationFlags(const SchreyerSyzygyComputationFlags &attr)
Computing syzygies after Schreyer.
const ideal m_idTails
input tails
int status int void size_t count int const void size_t count const char int flags
const int OPT__NOCACHING
no caching/stores/lookups