34#define BUCKETS_FOR_NORO_RED 1
35#define SR_HDL(A) ((long)(A))
39#define ADD_LATER_SIZE 500
153#define degbound(p) assume(pTotaldegree(p)<10)
240 for(
i =
b->buckets_used;
i >= 0;
i--)
243 s +=
b->buckets_length[
i] ;
245#ifdef HAVE_COEF_BUCKETS
247 if(
b->coef[0] !=
NULL)
313 for(
i =
b->buckets_used;
i >= 0;
i--)
316 s +=
b->buckets_length[
i] ;
318#ifdef HAVE_COEF_BUCKETS
320 if(
b->coef[0] !=
NULL)
484 long unsigned d =
ca->pTotaldegree (
lm);
493 for(
i =
b->buckets_used;
i >= 0;
i--)
498 if((
ca->pTotaldegree (
b->buckets[
i]) <= d)
501 s +=
b->buckets_length[
i];
579#ifdef HAVE_COEF_BUCKETS
639 p1 = *((poly *)
ap1);
640 p2 = *((poly *)
ap2);
655 for(
int i = 0;
i <= strat->
sl;
i++)
667 for(
int i = 0;
i <= strat->
sl;
i++)
720 int *a = (
int *)
omalloc (
qn *
sizeof (
int));
735 for(
i = 0;
i <
qn;
i++)
749 for(
i =
qn - 1;
i >= 0;
i--)
766 poly p1 = c->
S->m[
pos1];
767 poly p2 = c->
S->m[
pos2];
823 for(
i =
l + 1;
i <= u;
i++)
857 for(
int n = 0; ((n < c->
n) && (
i_con[n] >= 0)); n++)
874 for(
i = 0;
i <= strat->
sl;
i++)
890 P.sev = strat->
sevS[
i];
899 for(
j = 0;
j < c->
n;
j++)
901 if(c->
S->m[
j] == P.p)
920 for(
i = bucket->buckets_used;
i >= 0;
i--)
922 if(bucket->buckets[
i])
923 sum += bucket->buckets_length[
i];
947 P.FDeg = c->
r->pFDeg (P.p, c->
r);
975 for(
i = 0;
i < pos;
i++)
980 for(
i = pos + 1;
i < c->
n;
i++)
1005 strat->
S[
i] = strat->
S[
i - 1];
1042 strat->
S[
i] = strat->
S[
i + 1];
1180 for(
int n = 0; ((n < c->
n) && (
i_con[n] >= 0)); n++)
1215 for(
int m = 0; ((
m < c->
n) && (
i_con[
m] >= 0));
m++)
1226 for(
int m = 0; ((
m < c->
n) && (
j_con[
m] >= 0));
m++)
1404#define ENLARGE(pointer, type) pointer=(type*) omreallocSize(pointer, old*sizeof(type),c->array_lengths*sizeof(type))
1406#define ENLARGE_ALIGN(pointer, type) {if(pointer)\
1407 pointer=(type*)omReallocSize(pointer, old*sizeof(type),c->array_lengths*sizeof(type));\
1408 else pointer=(type*)omAllocAligned(c->array_lengths*sizeof(type));}
1431#ifndef USE_STDVECBOOL
1474#ifdef USE_STDVECBOOL
1493 for(
j = 0;
j <
i;
j++)
1603 if (
i>
j) {
s->i=
i;
s->j=
j;}
1604 else {
s->i=
j;
s->j=
i;}
1649 for(upper = lower + 1; upper <
spc; upper++)
1673 for(; lower <= upper; lower++)
1694 for(lower = lower + 1; lower <= upper; lower++)
1804 P.SetShortExpVector ();
1819 if((
j >= 0) && ((!n) ||
1820 ((strat->
lenS[
j] <= n) &&
1851 P.SetShortExpVector ();
1882 for(
i = 0;
i <= strat->
sl;
i++)
1884 if((strat->
lenS[
i] > 2)
1954 while(*node !=
NULL)
1956 int c =
pLmCmp (
p, (*node)->p);
1960 node = &((*node)->r);
1962 node = &((*node)->l);
1977 if((
r2.p !=
ro.p) || (
r2.sev !=
ro.sev))
1984 return -
pLmCmp (*((poly *) a), *((poly *)
b));
2015 for(
i = 0;
i <
pn;
i++)
2018 for(
j = 0;
j <
tn;
j++)
2057 for(
i = 0;
i <
pn;
i++)
2072 for(
i = 0;
i <
pn;
i++)
2103 for(
j = 0;
j <
pn;
j++)
2109 for(
j = 0;
j <
pn;
j++)
2116 for(
j = 0;
j <
pn;
j++)
2143#ifndef NORO_NON_POLY
2144void NoroCache::evaluateRows ()
2175 poly
p =
dn->value_poly;
2176#ifndef NORO_SPARSE_ROWS_PRE
2224 if(
i !=
dn->value_len)
2226 PrintS (
"F4 calc wrong, as poly len was wrong\n");
2235 NoroCache::evaluatePlaceHolder (
number * row,
2236 std::vector < NoroPlaceHolder >
2244 for(
i = 0;
i <
s;
i++)
2254 #ifndef NORO_SPARSE_ROWS_PRE
2287 int *idx_array =
ref_row->idx_array;
2291 for(
j = 0;
j < n;
j++)
2293 int idx = idx_array[
j];
2300 for(
j = 0;
j < n;
j++)
2302 int idx = idx_array[
j];
2313 for(
i = 0;
i <
s;
i++)
2323 #ifndef NORO_SPARSE_ROWS_PRE
2355 int *idx_array =
ref_row->idx_array;
2359 for(
j = 0;
j < n;
j++)
2361 int idx = idx_array[
j];
2368 for(
j = 0;
j < n;
j++)
2370 int idx = idx_array[
j];
2384#ifndef NORO_NON_POLY
2510#ifndef NORO_NON_POLY
2536 if((!(red.changed)) && (!(red.onlyBorrowed)))
2555 if(red.onlyBorrowed)
2582#ifdef NORO_SPARSE_ROWS_PRE
2605#ifndef NORO_NON_POLY
2609 std::vector < NoroPlaceHolder >
res;
2617 assume (red.onlyBorrowed);
2623 assume (!((
h.ref->value_poly ==
NULL) && (
h.ref->value_len != 0)));
2624 if(
h.ref->value_poly)
2645 for(
j = 0;
j <
pn;
j++)
2724 for(
i = 0;
i < c->
n;
i++)
2736 poly *
p = (poly *)
omAlloc ((max_pairs + 1) *
sizeof (poly));
2739 while(
i < max_pairs)
2804 if((!c->
nc) & (!(use_noro)))
2832#ifdef TGB_RESORT_PAIRS
2833 c->replaced =
new bool[c->
n];
2883 for(
j = 0;
j <
i;
j++)
2892 buf[
j].initial_quality =
buf[
j].guess_quality (c);
2904#ifdef TGB_RESORT_PAIRS
2915 if((c->replaced[c->
apairs[e]->
i]) || (c->replaced[c->
apairs[e]->
j]))
2928 for(
k = 0;
k <
i;
k++)
2950 for(
j = 0;
j <
i;
j++)
2991#ifdef TGB_RESORT_PAIRS
3028 P.SetShortExpVector ();
3073 P.SetShortExpVector ();
3151 p1 = *((poly *)
ap1);
3152 p2 = *((poly *)
ap2);
3173 for(
int i = 0;
i <
s;
i++)
3219 poly t =
I->m[
hzz]->next;
3286#ifdef USE_STDVECBOOL
3361 for(
i = 1;
i <
n;
i++)
3401 if(
s->lcm_of_lm !=
NULL)
3403 add[pos] =
s->lcm_of_lm;
3462#ifndef USE_STDVECBOOL
3463 for(
int z = 1 ; z < c->
n; z++)
3473 for(
int z = 0; z < c->
n; z++)
3495 for(
i = 0;
i < c->
n;
i++)
3506 Print (
"\nNF:%i product criterion:%i, ext_product criterion:%i \n",
3515 for(
j = 0;
j < c->
n;
j++)
3545 for(
i = 0;
i < c->
n;
i++)
3550 for(
j = 0;
j < c->
n;
j++)
3552 if((c->
S->m[
j] ==
NULL) || (
i ==
j))
3729 for(
int i = 0;
i < c->
n;
i++)
3735 poly tail = c->
S->m[
i]->next;
3736 poly prev = c->
S->m[
i];
3738 while((tail !=
NULL) && (
pLmCmp (tail, monom) >= 0))
3743 prev->next = tail->next;
3762 for(
int z = 0; z <= c->
strat->
sl; z++)
3771 for(
int z =
new_pos - 1; z >= 0; z--)
3812 for(deg = lower; deg <= upper; deg++)
3815 for(
i = 0;
i <
n;
i++)
3871 for(
i = 0;
i < this->
n; i++)
3873 for(
j = 0;
j <
i;
j++)
3988 if(a->
i + a->
j <
b->i +
b->j)
3990 if(a->
i + a->
j >
b->i +
b->j)
4020 if(a->
i + a->
j <
b->i +
b->j)
4022 if(a->
i + a->
j >
b->i +
b->j)
4119 if(
b->buckets[
i] !=
NULL)
4185 int best =
erg.to_reduce_u + 1;
4223 if(
erg.to_reduce_u >
erg.to_reduce_l)
4230 los[
erg.to_reduce_u].p, c);
4232 int best =
erg.to_reduce_u + 1;
4248 erg.reduce_by =
erg.to_reduce_u;
4260 PrintS (
"Wrong wlen_type");
4281 else if(
erg.reduce_by < c->
n / 4)
4287 los[
erg.to_reduce_u].flatten ();
4289 &
erg.expand_length);
4306 if(
erg.reduce_by >
erg.to_reduce_u)
4330 int il =
erg.reduce_by;
4336 qc =
los[
il].guess_quality (c);
4352 int bp =
erg.to_reduce_u;
4357 int j =
erg.reduce_by;
4367 for(z = c->
n; z; z--)
4369 if(
p == c->
S->m[z - 1])
4380#ifdef TGB_RESORT_PAIRS
4418#ifdef FIND_DETERMINISTIC
4497 for(
i =
l;
i <= u;
i++)
4532 erg.to_reduce_u =
i;
4540 erg.to_reduce_l =
i2;
4556 erg.to_reduce_u =
i - 1;
4557 erg.to_reduce_l =
i2;
4641 for(
i =
l;
i <= u;
i++)
4761 if(
erg.reduce_by < 0)
4776 for(
i =
erg.to_reduce_l;
i <=
erg.to_reduce_u;
i++)
4782 if(
los[
i].guess_quality (c)
4787 los[
i].canonicalize ();
4792 los[
i].clear_to_poly ();
4821#ifdef FIND_DETERMINISTIC
4825 (
i+2)*
sizeof(poly));
4922 for(
i =
l;
i <= u;
i++)
4926 for(
i =
l;
i <= u;
i++)
4952 int rn =
erg.reduce_by;
4984 || ((c->
nc) || (
erg.to_reduce_u -
erg.to_reduce_l > 5)))
5023 int reducer_deg = 0;
5036 reducer_deg =
lm_deg + ecart;
5054 r[
erg.reduce_by].
sev = sev;
5156template class std::vector<DataNoroCacheNode<unsigned char>*>;
5157template class std::vector<DataNoroCacheNode<unsigned int>*>;
5158template class std::vector<DataNoroCacheNode<unsigned short>*>;
5159template class std::vector<PolySimple>;
static int si_max(const int a, const int b)
static int si_min(const int a, const int b)
const CanonicalForm CFMap CFMap & N
static CanonicalForm bound(const CFMatrix &M)
template void noro_step< tgb_uint8 >(poly *p, int &pn, slimgb_alg *c)
template void noro_step< tgb_uint32 >(poly *p, int &pn, slimgb_alg *c)
template void noro_step< tgb_uint16 >(poly *p, int &pn, slimgb_alg *c)
SparseRow< number_type > * row
NoroCacheNode ** branches
int nIrreducibleMonomials
DataNoroCacheNode< number_type > * getCacheReference(poly term)
static const int backLinkCode
poly_tree_node * top_level
wlen_type guess_quality(slimgb_alg *c)
makes on each red_object in a region a single_step
virtual ~reduction_step()
virtual void reduce(red_object *r, int l, int u)
we assume that all occurring red_objects have same lm, and all occ. lm's in r[l......
virtual void pre_reduce(red_object *r, int l, int u)
virtual void reduce(red_object *r, int l, int u)
we assume that all occurring red_objects have same lm, and all occ. lm's in r[l......
virtual void do_reduce(red_object &ro)
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
void(* initEcart)(TObject *L)
unsigned long pTotaldegree(poly p)
int_pair_node * soon_free
sorted_pair_node ** apairs
BOOLEAN use_noro_last_block
int extended_product_crit
sorted_pair_node ** tmp_spn
void introduceDelayedPairs(poly *pa, int s)
unsigned int reduction_steps
poly_array_list * F_minus
slimgb_alg(ideal I, int syz_comp, BOOLEAN F4, int deg_pos)
void cleanDegs(int lower, int upper)
int syz_comp
array_lengths should be greater equal n;
int pTotaldegree_full(poly p)
BOOLEAN eliminationProblem
wlen_type * weighted_lengths
poly_list_node * to_destroy
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static BOOLEAN pa(leftv res, leftv args)
void bit_reduce(poly &f, ring r)
const CanonicalForm int s
const Variable & v
< [in] a sqrfree bivariate poly
CFArray copy(const CFList &list)
write elements of list into an array
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define idDelete(H)
delete an ideal
ideal id_Copy(ideal h1, const ring r)
copy an ideal
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN length(leftv result, leftv arg)
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
void kBucketDeleteAndDestroy(kBucket_pt *bucket_pt)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
void kBucketDestroy(kBucket_pt *bucket_pt)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
poly kBucketExtractLm(kBucket_pt bucket)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
const poly kBucketGetLm(kBucket_pt bucket)
void kBucketSimpleContent(kBucket_pt bucket)
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
#define MAX_BUCKET
Bucket definition (should be no one elses business, though)
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
ideal kInterRed(ideal F, const ideal Q)
void initBuchMoraPos(kStrategy strat)
void initBuchMoraCrit(kStrategy strat)
void deleteInS(int i, kStrategy strat)
void initEcartBBA(TObject *h)
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
poly redNFTail(poly h, const int sl, kStrategy strat)
static void nc_kBucketPolyRed_Z(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
static bool rIsSCA(const ring r)
static poly nc_CreateSpoly(const poly p1, const poly p2, const ring r)
poly sca_pp_Mult_xi_pp(short i, const poly pPoly, const ring rRing)
static FORCE_INLINE int nlQlogSize(number n, const coeffs r)
only used by slimgb (tgb.cc)
'SR_INT' is the type of those integers small enough to fit into 29 bits.
STATIC_VAR unsigned add[]
static number npNeg(number c, const coeffs r)
long npInt(number &n, const coeffs r)
static BOOLEAN npIsOne(number a, const coeffs)
static number npAddM(number a, number b, const coeffs r)
static number npInit(long i, const coeffs r)
static number nvMult(number a, number b, const coeffs r)
static number npMult(number a, number b, const coeffs r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define __p_GetComp(p, r)
gmp_float exp(const gmp_float &a)
#define omreallocSize(addr, o_size, size)
#define omGetSpecBin(size)
#define omUnGetSpecBin(bin_ptr)
#define TEST_OPT_INTSTRATEGY
#define TEST_V_UPTORADICAL
#define TEST_OPT_DEGBOUND
#define TEST_OPT_REDTHROUGH
#define TEST_V_MODPSOLVSB
unsigned long p_GetShortExpVector(const poly p, const ring r)
poly p_Cleardenom(poly p, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
static int pLength(poly a)
#define p_LmEqual(p1, p2, r)
#define __pp_Mult_nn(p, n, r)
static poly pp_Mult_mm(poly p, poly m, const ring r)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
static void p_Setm(poly p, const ring r)
static number p_SetCoeff(poly p, number n, ring r)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static void p_Delete(poly *p, const ring r)
static poly p_Init(const ring r, omBin bin)
static poly p_Copy(poly p, const ring r)
returns a copy of p
#define __p_Mult_nn(p, n, r)
void rChangeCurrRing(ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pHasNotCF(p1, p2)
#define pExpVectorDiff(pr, p1, p2)
#define pGetComp(p)
Component.
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
#define pExpVectorSub(p1, p2)
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
#define pGetExp(p, i)
Exponent.
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
#define pCopy(p)
return a copy of the poly
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
void PrintS(const char *s)
ring rAssure_TDeg(ring r, int &pos)
BOOLEAN rRing_has_CompLastBlock(const ring r)
void rDelete(ring r)
unconditionally deletes fields in r
static BOOLEAN rField_is_Zp(const ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rBlocks(const ring r)
static BOOLEAN rField_is_Q(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
static short scaLastAltVar(ring r)
static short scaFirstAltVar(ring r)
int status int void * buf
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
void id_Compactify(ideal id, const ring r)
static int fwbw(red_object *los, int i)
BOOLEAN is_valid_ro(red_object &ro)
static poly redNFTail(poly h, const int sl, kStrategy strat, int len)
ideal t_rep_gb(const ring r, ideal arg_I, int syz_comp, BOOLEAN F4_mode)
static void shorten_tails(slimgb_alg *c, poly monom)
static void go_on(slimgb_alg *c)
static poly gcd_of_terms(poly p, ring r)
BOOLEAN good_has_t_rep(int i, int j, slimgb_alg *c)
int tgb_pair_better_gen2(const void *ap, const void *bp)
static const int bundle_size
static int tgb_pair_better_gen(const void *ap, const void *bp)
static void clearS(poly p, unsigned long p_sev, int l, int *at, int *k, kStrategy strat)
static int pELength(poly p, slimgb_alg *c, int l)
sorted_pair_node ** spn_merge(sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
static wlen_type pair_weighted_length(int i, int j, slimgb_alg *c)
static void move_forward_in_S(int old_pos, int new_pos, kStrategy strat)
void now_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *c)
void clean_top_of_pair_list(slimgb_alg *c)
#define ENLARGE(pointer, type)
static void mass_add(poly *p, int pn, slimgb_alg *c)
static int get_last_dp_block_start(ring r)
static wlen_type coeff_mult_size_estimate(int s1, int s2, ring r)
int find_best(red_object *r, int l, int u, wlen_type &w, slimgb_alg *c)
returns position sets w as weight
static BOOLEAN monomial_root(poly m, ring r)
int search_red_object_pos(red_object *a, int top, red_object *key)
static int multi_reduction_clear_zeroes(red_object *los, int losl, int l, int u, int syzComp)
static int * make_connections(int from, int to, poly bound, slimgb_alg *c)
sorted_pair_node ** add_to_basis_ideal_quotient(poly h, slimgb_alg *c, int *ip)
static BOOLEAN pair_better(sorted_pair_node *a, sorted_pair_node *b, slimgb_alg *c=NULL)
static poly p_Init_Special(const ring r)
#define ENLARGE_ALIGN(pointer, type)
static void sort_region_down(red_object *los, int l, int u, slimgb_alg *)
int slim_nsize(number n, ring r)
static wlen_type pSLength(poly p, int l)
static BOOLEAN lies_in_last_dp_block(poly p, slimgb_alg *c)
sorted_pair_node * quick_pop_pair(slimgb_alg *c)
wlen_type kEBucketLength(kBucket *b, poly lm, slimgb_alg *ca)
static int posInPairs(sorted_pair_node **p, int pn, sorted_pair_node *qe, slimgb_alg *c, int an=0)
static const int delay_factor
int kFindDivisibleByInS_easy(kStrategy strat, const red_object &obj)
static int poly_crit(const void *ap1, const void *ap2)
static int simple_posInS(kStrategy strat, poly p, int len, wlen_type wlen)
static wlen_type quality_of_pos_in_strat_S(int pos, slimgb_alg *c)
static void c_S_element_changed_hook(int pos, slimgb_alg *c)
sorted_pair_node * top_pair(slimgb_alg *c)
static void replace_pair(int &i, int &j, slimgb_alg *c)
static void multi_reduction_find(red_object *los, int, slimgb_alg *c, int startf, find_erg &erg)
static void line_of_extended_prod(int fixpos, slimgb_alg *c)
static BOOLEAN trivial_syzygie(int pos1, int pos2, poly bound, slimgb_alg *c)
static int iq_crit(const void *ap, const void *bp)
static poly redNF2(poly h, slimgb_alg *c, int &len, number &m, int n=0)
static void simplify_poly(poly p, ring r)
static void multi_reduction(red_object *los, int &losl, slimgb_alg *c)
static void add_later(poly p, const char *prot, slimgb_alg *c)
static poly pOne_Special(const ring r=currRing)
static poly redTailShort(poly h, kStrategy strat)
static void cleanS(kStrategy strat, slimgb_alg *c)
static BOOLEAN ascending(int *i, int top)
static wlen_type quality_of_pos_in_strat_S_mult_high(int pos, poly high, slimgb_alg *c)
static void multi_reduce_step(find_erg &erg, red_object *r, slimgb_alg *c)
static wlen_type do_pELength(poly p, slimgb_alg *c, int dlm=-1)
ideal do_t_rep_gb(ring, ideal arg_I, int syz_comp, BOOLEAN F4_mode, int deg_pos)
static wlen_type pQuality(poly p, slimgb_alg *c, int l=-1)
static void move_backward_in_S(int old_pos, int new_pos, kStrategy strat)
void free_sorted_pair_node(sorted_pair_node *s, const ring r)
BOOLEAN lenS_correct(kStrategy strat)
void init_with_mac_poly(tgb_sparse_matrix *mat, int row, mac_poly m)
int terms_sort_crit(const void *a, const void *b)
static void canonicalize_region(red_object *los, int l, int u, slimgb_alg *)
static BOOLEAN polynomial_root(poly h, ring r)
poly free_row_to_poly(tgb_sparse_matrix *mat, int row, poly *monoms, int monom_index)
static int bucket_guess(kBucket *bucket)
wlen_type kSBucketLength(kBucket *b, poly lm=NULL)
TODO CoefBuckets bercksichtigen.
static void super_clean_top_of_pair_list(slimgb_alg *c)
static void multi_reduction_lls_trick(red_object *los, int, slimgb_alg *c, find_erg &erg)
static int red_object_better_gen(const void *ap, const void *bp)
static void length_one_crit(slimgb_alg *c, int pos, int len)
static BOOLEAN has_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *state)
static void add_to_reductors(slimgb_alg *c, poly h, int len, int ecart, BOOLEAN simplified=FALSE)
static BOOLEAN pHasNotCFExtended(poly p1, poly p2, poly m)
static BOOLEAN extended_product_criterion(poly p1, poly gcd1, poly p2, poly gcd2, slimgb_alg *c)
static const int bundle_size_noro
static BOOLEAN state_is(calc_state state, const int &i, const int &j, slimgb_alg *c)
static BOOLEAN elength_is_normal_length(poly p, slimgb_alg *c)
int tgb_pair_better_gen2(const void *ap, const void *bp)
sorted_pair_node ** spn_merge(sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
void now_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *c)
void simplest_gauss_modp(number_type *a, int nrows, int ncols)
sorted_pair_node ** add_to_basis_ideal_quotient(poly h, slimgb_alg *c, int *ip)
void write_poly_to_row(number_type *row, poly h, poly *terms, int tn)
int pos_helper(kStrategy strat, poly p, len_type len, set_type setL, polyset set)
poly row_to_poly(number_type *row, poly *terms, int tn, ring r)
wlen_type expected_length
void free_sorted_pair_node(sorted_pair_node *s, const ring r)
void noro_step(poly *p, int &pn, slimgb_alg *c)