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)
442 return r->block0[last_block];
493 for(
i =
b->buckets_used;
i >= 0;
i--)
501 s +=
b->buckets_length[
i];
579#ifdef HAVE_COEF_BUCKETS
623static int LObject_better_gen (
const void *
ap,
const void *bp)
636static int pLmCmp_func_inverted (
const void *ap1,
const void *ap2)
639 p1 = *((poly *) ap1);
640 p2 = *((poly *) ap2);
654 long not_sev = ~obj.sev;
655 for(
int i = 0;
i <= strat->
sl;
i++)
667 for(
int i = 0;
i <= strat->
sl;
i++)
711 if(
i[top] <
i[top - 1])
720 int *a = (
int *)
omalloc (qn *
sizeof (
int));
735 for(
i = 0;
i < qn;
i++)
749 for(
i = qn - 1;
i >= 0;
i--)
756 memmove (
p + a[
i] + (1 +
i),
p + a[
i],
size);
766 poly p1 = c->
S->m[pos1];
767 poly p2 = c->
S->m[pos2];
776 if((gcd1 !=
NULL) && (gcd2 !=
NULL))
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++)
887 while(i <= strat->sl)
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];
943 memset (&P, 0,
sizeof (P));
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++)
992 assume (old_pos >= new_pos);
993 poly
p = strat->
S[old_pos];
994 int ecart = strat->
ecartS[old_pos];
995 long sev = strat->
sevS[old_pos];
996 int s_2_r = strat->
S_2_R[old_pos];
1001 length_w = strat->
lenSw[old_pos];
1003 for(
i = old_pos;
i > new_pos;
i--)
1005 strat->
S[
i] = strat->
S[
i - 1];
1011 for(
i = old_pos;
i > new_pos;
i--)
1014 for(
i = old_pos;
i > new_pos;
i--)
1017 strat->
S[new_pos] =
p;
1018 strat->
ecartS[new_pos] = ecart;
1019 strat->
sevS[new_pos] = sev;
1020 strat->
S_2_R[new_pos] = s_2_r;
1023 strat->
lenSw[new_pos] = length_w;
1029 assume (old_pos <= new_pos);
1030 poly
p = strat->
S[old_pos];
1031 int ecart = strat->
ecartS[old_pos];
1032 long sev = strat->
sevS[old_pos];
1033 int s_2_r = strat->
S_2_R[old_pos];
1038 length_w = strat->
lenSw[old_pos];
1040 for(
i = old_pos;
i < new_pos;
i++)
1042 strat->
S[
i] = strat->
S[
i + 1];
1048 for(
i = old_pos;
i < new_pos;
i++)
1051 for(
i = old_pos;
i < new_pos;
i++)
1054 strat->
S[new_pos] =
p;
1055 strat->
ecartS[new_pos] = ecart;
1056 strat->
sevS[new_pos] = sev;
1057 strat->
S_2_R[new_pos] = s_2_r;
1060 strat->
lenSw[new_pos] = length_w;
1067 int *cans = (
int *)
omAlloc (c->
n * sizeof (
int));
1068 int *connected = (
int *)
omAlloc (c->
n * sizeof (
int));
1070 int cans_length = 1;
1071 connected[0] = from;
1072 int last_cans_pos = -1;
1073 int connected_length = 1;
1074 long neg_bounds_short = ~p_GetShortExpVector (
bound, c->
r);
1076 int not_yet_found = cans_length;
1077 int con_checked = 0;
1082 if((con_checked < connected_length) && (not_yet_found > 0))
1084 pos = connected[con_checked];
1085 for(
int i = 0;
i < cans_length;
i++)
1094 connected[connected_length] = cans[
i];
1099 if(connected[connected_length - 1] == to)
1101 if(connected_length < c->n)
1103 connected[connected_length] = -1;
1114 for(last_cans_pos++; last_cans_pos <= c->
n; last_cans_pos++)
1116 if(last_cans_pos == c->
n)
1118 if(connected_length < c->n)
1120 connected[connected_length] = -1;
1125 if((last_cans_pos == from) || (last_cans_pos == to))
1129 neg_bounds_short, c->
r))
1131 cans[cans_length] = last_cans_pos;
1137 for(
int i = 0;
i < con_checked;
i++)
1139 if(
has_t_rep (connected[
i], last_cans_pos, c))
1141 connected[connected_length] = last_cans_pos;
1143 cans[cans_length - 1] = -1;
1145 if(connected[connected_length - 1] == to)
1147 if(connected_length < c->n)
1149 connected[connected_length] = -1;
1159 if(connected_length < c->n)
1161 connected[connected_length] = -1;
1168static inline poly p_MoveHead (poly
p,
omBin b)
1191 for(
int n = 0; ((n < c->
n) && (i_con[n] >= 0)); n++)
1222 sugar +=
si_max (t_i, t_j);
1226 for(
int m = 0; ((
m < c->
n) && (i_con[
m] >= 0));
m++)
1237 for(
int m = 0; ((
m < c->
n) && (j_con[
m] >= 0));
m++)
1291 if(
l >= strat->
lenS[*at])
1351 res *= el1 + el2 - 2;
1415#define ENLARGE(pointer, type) pointer=(type*) omreallocSize(pointer, old*sizeof(type),c->array_lengths*sizeof(type))
1417#define ENLARGE_ALIGN(pointer, type) {if(pointer)\
1418 pointer=(type*)omReallocSize(pointer, old*sizeof(type),c->array_lengths*sizeof(type));\
1419 else pointer=(type*)omAllocAligned(c->array_lengths*sizeof(type));}
1442#ifndef USE_STDVECBOOL
1460 ecart = sugar - c->
T_deg[
i];
1482 c->
states.push_back (dynamic_bitset <> (
i));
1485#ifdef USE_STDVECBOOL
1487 c->
states.push_back (vector < bool > (
i));
1504 for(
j = 0;
j <
i;
j++)
1614 if (
i>
j) {
s->i=
i;
s->j=
j;}
1615 else {
s->i=
j;
s->j=
i;}
1660 for(upper = lower + 1; upper < spc; upper++)
1662 if(!
pLmEqual (nodes[lower]->lcm_of_lm, nodes[upper]->lcm_of_lm))
1666 if(
has_t_rep (nodes[upper]->
i, nodes[upper]->
j, c))
1672 for(z = 0; z < spc_final; z++)
1675 (nodes_final[z]->lcm_of_lm, nodes[lower]->lcm_of_lm, c->
r))
1684 for(; lower <= upper; lower++)
1688 nodes[lower] =
NULL;
1695 p_Test (nodes[lower]->lcm_of_lm, c->
r);
1699 nodes_final[spc_final] =
1702 *(nodes_final[spc_final++]) = *(nodes[lower]);
1704 nodes[lower] =
NULL;
1705 for(lower = lower + 1; lower <= upper; lower++)
1709 nodes[lower] =
NULL;
1718 assume (spc_final <= spc);
1753 m_iLastAltVar - m_iFirstAltVar + 1;
1756 poly *array_arg = (poly *)
omalloc (
N *
sizeof (poly));
1760 for(
unsigned short v = m_iFirstAltVar;
v <= m_iLastAltVar;
v++)
1815 P.SetShortExpVector ();
1830 if((
j >= 0) && ((!n) ||
1831 ((strat->
lenS[
j] <= n) &&
1848 number m2 =
nMult (
m, coef);
1862 P.SetShortExpVector ();
1893 for(
i = 0;
i <= strat->
sl;
i++)
1895 if((strat->
lenS[
i] > 2)
1910 for(
i = 0;
i < fixpos;
i++)
1920 for(
i = fixpos + 1;
i < c->
n;
i++)
1965 while(*node !=
NULL)
1967 int c =
pLmCmp (
p, (*node)->p);
1971 node = &((*node)->r);
1973 node = &((*node)->l);
1988 if((r2.
p != ro.
p) || (r2.
sev != ro.
sev))
1995 return -
pLmCmp (*((poly *) a), *((poly *)
b));
1999static void unify_terms (poly * terms,
int &sum)
2009 terms[++
last] = terms[curr];
2018export_mat (number *
number_array,
int pn,
int tn,
const char *format_str,
2022 sprintf (matname, format_str, mat_nr);
2023 FILE *out = fopen (matname,
"w");
2025 fprintf (out,
"mat=[\n");
2026 for(
i = 0;
i < pn;
i++)
2028 fprintf (out,
"[\n");
2029 for(
j = 0;
j < tn;
j++)
2033 fprintf (out,
", ");
2038 fprintf (out,
"],\n");
2040 fprintf (out,
"],\n");
2042 fprintf (out,
"]\n");
2052linalg_step_modp (poly *
p, poly * p_out,
int &pn, poly * terms,
int tn,
2059 const number_type zero = 0;
2060 int array_size = pn * tn;
2062 (number_type *)
omalloc (pn * tn *
sizeof (number_type));
2064 for(
i = 0;
i < array_size;
i++)
2068 for(
i = 0;
i < pn;
i++)
2077 export_mat (
number_array, pn, tn,
"mat%i.py", ++export_n);
2083 for(
i = 0;
i < pn;
i++)
2100 p_out[p_pos++] =
NULL;
2103 export_mat (
number_array, pn, tn,
"mat%i.py", ++export_n);
2111 int *ibuf = (
int *)
omalloc (pn *
sizeof (
int));
2114 for(
j = 0;
j < pn;
j++)
2120 for(
j = 0;
j < pn;
j++)
2127 for(
j = 0;
j < pn;
j++)
2129 memmove (big_sbuf + partsum, sbuf[
j],
2154#ifndef NORO_NON_POLY
2155void NoroCache::evaluateRows ()
2187#ifndef NORO_SPARSE_ROWS_PRE
2217 row->
array = (number *)
omalloc ((len) *
sizeof (number));
2218 memcpy (row->
array, a + row->
begin, len * sizeof (number));
2237 PrintS (
"F4 calc wrong, as poly len was wrong\n");
2246 NoroCache::evaluatePlaceHolder (number * row,
2247 std::vector < NoroPlaceHolder >
2251 int s = place_holders.size ();
2255 for(
i = 0;
i <
s;
i++)
2258 number coef = place_holders[
i].coef;
2265 #ifndef NORO_SPARSE_ROWS_PRE
2269 number *ref_begin = ref_row->
array;
2270 number *ref_end = ref_row->
array + (ref_row->
end - ref_row->
begin);
2271 number *my_pos = row + ref_row->
begin;
2275 while(ref_begin != ref_end)
2284 while(ref_begin != ref_end)
2287 *my_pos =
npAddM (*my_pos, *ref_begin);
2296 int n = ref_row->
len;
2302 for(
j = 0;
j < n;
j++)
2304 int idx = idx_array[
j];
2305 number ref_coef = coef_array[
j];
2311 for(
j = 0;
j < n;
j++)
2313 int idx = idx_array[
j];
2314 number ref_coef = coef_array[
j];
2315 row[idx] =
npAddM (row[idx], ref_coef);
2324 for(
i = 0;
i <
s;
i++)
2327 number coef = place_holders[
i].coef;
2334 #ifndef NORO_SPARSE_ROWS_PRE
2338 number *ref_begin = ref_row->
array;
2339 number *ref_end = ref_row->
array + (ref_row->
end - ref_row->
begin);
2340 number *my_pos = row + ref_row->
begin;
2344 while(ref_begin != ref_end)
2353 while(ref_begin != ref_end)
2355 *my_pos =
npAddM (*my_pos, *ref_begin);
2364 int n = ref_row->
len;
2370 for(
j = 0;
j < n;
j++)
2372 int idx = idx_array[
j];
2373 number ref_coef = coef_array[
j];
2379 for(
j = 0;
j < n;
j++)
2381 int idx = idx_array[
j];
2382 number ref_coef = coef_array[
j];
2383 row[idx] =
npAddM (row[idx], ref_coef);
2395#ifndef NORO_NON_POLY
2399 MonRedRes res_holder;
2402 res_holder.changed =
TRUE;
2415 res_holder.ref = ref;
2416 res_holder.onlyBorrowed =
TRUE;
2417 res_holder.changed =
TRUE;
2425 poly cache_lookup = cache->
lookup (t, succ, res_holder.len);
2428 if(cache_lookup == t)
2433 res_holder.changed =
FALSE;
2435 res_holder.coef =
npInit (1);
2437 res_holder.onlyBorrowed =
FALSE;
2444 res_holder.p = cache_lookup;
2446 res_holder.onlyBorrowed =
TRUE;
2474 res = noro_red_non_unique (
res, res_holder.len, cache, c);
2480 res_holder.changed =
TRUE;
2482 res_holder.coef = coef_bak;
2483 res_holder.onlyBorrowed =
TRUE;
2484 res_holder.ref = ref;
2495 res_holder.ref = cache->
insert (t, t, res_holder.len);
2500 res_holder.changed =
FALSE;
2503 res_holder.coef =
npInit (1);
2504 res_holder.onlyBorrowed =
FALSE;
2510 res_holder.coef = coef_bak;
2511 res_holder.onlyBorrowed =
TRUE;
2512 res_holder.changed =
FALSE;
2521#ifndef NORO_NON_POLY
2534 poly unchanged_head =
NULL;
2535 poly unchanged_tail =
NULL;
2536 int unchanged_size = 0;
2546 MonRedRes red = noro_red_mon (t,
FALSE, cache, c);
2547 if((!(red.changed)) && (!(red.onlyBorrowed)))
2554 pNext (unchanged_tail) = red.p;
2555 pIter (unchanged_tail);
2559 unchanged_tail = red.p;
2560 unchanged_head = red.p;
2566 if(red.onlyBorrowed)
2593#ifdef NORO_SPARSE_ROWS_PRE
2616#ifndef NORO_NON_POLY
2617std::vector < NoroPlaceHolder > noro_red (poly
p,
int &len,
NoroCache * cache,
2620 std::vector < NoroPlaceHolder >
res;
2627 MonRedRes red = noro_red_mon (t,
TRUE, cache, c);
2628 assume (red.onlyBorrowed);
2634 assume (!((
h.ref->value_poly ==
NULL) && (
h.ref->value_len != 0)));
2635 if(
h.ref->value_poly)
2647 poly *reduced = (poly *)
omalloc (pn *
sizeof (poly));
2649 int *reduced_len = (
int *)
omalloc (pn *
sizeof (
int));
2656 for(
j = 0;
j < pn;
j++)
2666 h = noro_red (
p_Copy (
h, c->
r), h_len, &cache, c);
2676 reduced[reduced_c] =
h;
2677 reduced_len[reduced_c] = h_len;
2680 Print (
"%d ", h_len);
2683 int reduced_sum = 0;
2684 for(
j = 0;
j < reduced_c;
j++)
2686 reduced_sum += reduced_len[
j];
2688 poly *terms = (poly *)
omalloc (reduced_sum *
sizeof (poly));
2690 for(
j = 0;
j < reduced_c;
j++)
2692 poly
h = reduced[
j];
2698 assume (tc <= reduced_sum);
2701 assume (tc == reduced_sum);
2703 int nterms = reduced_sum;
2706 unify_terms (terms, nterms);
2709 int rank = reduced_c;
2710 linalg_step_modp (reduced,
p, rank, terms, nterms, c);
2735 for(
i = 0;
i < c->
n;
i++)
2747 poly *
p = (poly *)
omAlloc ((max_pairs + 1) *
sizeof (poly));
2750 while(
i < max_pairs)
2759 if(
s->deg > curr_deg)
2805 if((!c->
nc) & (!(use_noro)))
2833#ifdef TGB_RESORT_PAIRS
2834 c->replaced =
new bool[c->
n];
2884 for(
j = 0;
j <
i;
j++)
2893 buf[
j].initial_quality =
buf[
j].guess_quality (c);
2901 Print (
"%dM[%d,", curr_deg,
i);
2905#ifdef TGB_RESORT_PAIRS
2916 if((c->replaced[c->
apairs[e]->
i]) || (c->replaced[c->
apairs[e]->
j]))
2929 for(
k = 0;
k <
i;
k++)
2933 for(k2 = 0; k2 <
i; k2++)
2949 poly *add_those = (poly *)
omalloc0 (
i *
sizeof (poly));
2951 for(
j = 0;
j <
i;
j++)
2979 add_those[num_to_add++] =
p;
2985 mass_add (add_those, num_to_add, c);
2992#ifdef TGB_RESORT_PAIRS
3029 P.SetShortExpVector ();
3074 P.SetShortExpVector ();
3133 poly *set_this = &
p;
3138 (*set_this) =
pLmInit (monoms[monom_index - 1 - r->
exp]);
3140 set_this = &((*set_this)->next);
3152 p1 = *((poly *) ap1);
3153 p2 = *((poly *) ap2);
3174 for(
int i = 0;
i <
s;
i++)
3216 for(hzz = 0; hzz <
IDELEMS (I); hzz++)
3220 poly t = I->m[hzz]->next;
3290#ifdef USE_STDVECBOOL
3340 poly *array_arg = I->m;
3365 for(
i = 1;
i <
n;
i++)
3399 for(piter = 0; piter <=
pair_top; piter++)
3405 if(
s->lcm_of_lm !=
NULL)
3407 add[pos] =
s->lcm_of_lm;
3422 for(piter = 0; piter <=
pair_top; piter++)
3466#ifndef USE_STDVECBOOL
3467 for(
int z = 1 ; z < c->
n; z++)
3477 for(
int z = 0; z < c->
n; z++)
3499 for(
i = 0;
i < c->
n;
i++)
3510 Print (
"\nNF:%i product criterion:%i, ext_product criterion:%i \n",
3519 for(
j = 0;
j < c->
n;
j++)
3549 for(
i = 0;
i < c->
n;
i++)
3554 for(
j = 0;
j < c->
n;
j++)
3556 if((c->
S->m[
j] ==
NULL) || (
i ==
j))
3592 if(orig_ring != new_ring)
3609 s_h =
id_Copy (arg_I, orig_ring);
3613 ideal s_result =
do_t_rep_gb (new_ring, s_h, syz_comp, F4_mode, pos);
3615 if(orig_ring != new_ring)
3713 assume (arg_i < state->n);
3714 assume (arg_j < state->n);
3733 for(
int i = 0;
i < c->
n;
i++)
3739 poly tail = c->
S->m[
i]->next;
3740 poly prev = c->
S->m[
i];
3742 while((tail !=
NULL) && (
pLmCmp (tail, monom) >= 0))
3746 did_something =
TRUE;
3747 prev->next = tail->next;
3766 for(
int z = 0; z <= c->
strat->
sl; z++)
3775 for(
int z = new_pos - 1; z >= 0; z--)
3784 assume (new_pos <= old_pos);
3789 if(new_pos < old_pos)
3816 for(deg = lower; deg <= upper; deg++)
3819 for(
i = 0;
i <
n;
i++)
3863 new_pos = new_pos - 1;
3875 for(
i = 0;
i < this->
n; i++)
3877 for(
j = 0;
j <
i;
j++)
3962 return (c->
states[arg_i][arg_j] == state);
3965 return (c->
states[arg_j][arg_i] == state);
3992 if(a->
i + a->
j <
b->i +
b->j)
3994 if(a->
i + a->
j >
b->i +
b->j)
4024 if(a->
i + a->
j <
b->i +
b->j)
4026 if(a->
i + a->
j >
b->i +
b->j)
4055 for(
i = max_g_0;
i;
i--)
4061 if((max_g_0 == 0) && (
pGetExp (
m,
i) > 0))
4115static poly kBucketGcd (
kBucket *
b, ring r)
4123 if(
b->buckets[
i] !=
NULL)
4208 los[best].
p = los[best].
bucket->buckets[b_pos];
4209 qc =
pQuality (los[best].bucket->buckets[b_pos], c);
4239 assume (qc == los[best].guess_quality (c));
4244 los[best].
p = los[best].
bucket->buckets[b_pos];
4245 qc =
pQuality (los[best].bucket->buckets[b_pos], c);
4264 PrintS (
"Wrong wlen_type");
4270 los[best].
p = los[best].
bucket->buckets[b_pos];
4271 qc =
pQuality (los[best].bucket->buckets[b_pos], c);
4283 if(qc < quality_a / 2)
4337 while((il > 0) &&
pLmEqual (los[il - 1].
p, los[il].
p))
4359 clear_into = los[bp].
p;
4371 for(z = c->
n; z; z--)
4373 if(
p == c->
S->m[z - 1])
4384#ifdef TGB_RESORT_PAIRS
4386 c->replaced[pos_in_c] =
TRUE;
4389 c->
S->m[pos_in_c] = clear_into;
4390 c->
lengths[pos_in_c] = new_length;
4422#ifdef FIND_DETERMINISTIC
4451 if (i2 < step) step=i2;
4463 if((!incr) && (step == 1))
4488 step = (step + 1) / 2;
4501 for(
i =
l;
i <= u;
i++)
4521 assume ((startf == losl - 1)
4522 || (
pLmCmp (los[startf].
p, los[startf + 1].
p) == -1));
4539 int i2 =
fwbw (los,
i);
4554 int i2 =
fwbw (los,
i);
4598 memmove (los + (
int) (
last + 1 - deleted), los + (
last + 1),
4606 if((
last >= 0) && (
last != losl - 1))
4607 memmove (los + (
int) (
last + 1 - deleted), los +
last + 1,
4639 int r_size = u -
l + 1;
4642 int *new_indices = (
int *)
omalloc ((r_size) *
sizeof (int));
4645 for(
i =
l;
i <= u;
i++)
4656 new_indices[
i -
l] =
l;
4661 for(
int i = 0;
i < r_size;
i++)
4663 new_indices[
i] +=
i;
4664 los_region[
i] = los[
l +
i];
4665 assume ((
i == 0) || (new_indices[
i] > new_indices[
i - 1]));
4673 if(new_indices[
i] ==
j)
4675 los[
j] = los_region[
i];
4695 poly *delay = (poly *)
omAlloc (losl *
sizeof (poly));
4703 for(
i = 0;
i < losl;
i++)
4707 if(los[
i].initial_quality > max_initial_quality)
4714 int curr_pos = losl - 1;
4718 while(curr_pos >= 0)
4723 int pn_noro = curr_pos + 1;
4724 poly *p_noro = (poly *)
omAlloc (pn_noro *
sizeof (poly));
4725 for(
i = 0;
i < pn_noro;
i++)
4748 for(
i = 0;
i < pn_noro;
i++)
4750 los[
i].
p = p_noro[
i];
4759 curr_pos -= deleted;
4785 assume (los[
i].initial_quality > 0);
4786 if(los[
i].guess_quality (c)
4792 if(los[
i].guess_quality (c) >
delay_factor * max_initial_quality)
4798 delay[delay_s] = los[
i].
p;
4813 curr_pos -= deleted;
4825#ifdef FIND_DETERMINISTIC
4829 (
i+2)*
sizeof(poly));
4926 for(
i =
l;
i <= u;
i++)
4930 for(
i =
l;
i <= u;
i++)
4990 work_on_copy =
TRUE;
5027 int reducer_deg = 0;
5040 reducer_deg = lm_deg + ecart;
5044 if((!work_on_copy) && (!erg.
fromS))
5075template int term_nodes_sort_crit<unsigned char>(
void const*,
void const*);
5076template int term_nodes_sort_crit<unsigned int>(
void const*,
void const*);
5077template int term_nodes_sort_crit<unsigned short>(
void const*,
void const*);
5083template void simplest_gauss_modp<unsigned char>(
unsigned char*,
int,
int);
5084template void simplest_gauss_modp<unsigned int>(
unsigned int*,
int,
int);
5085template void simplest_gauss_modp<unsigned short>(
unsigned short*,
int,
int);
5088template int modP_lastIndexRow<unsigned char>(
unsigned char*,
int);
5089template int modP_lastIndexRow<unsigned int>(
unsigned int*,
int);
5090template int modP_lastIndexRow<unsigned short>(
unsigned short*,
int);
5120template void add_coef_times_dense<unsigned char>(
unsigned char*,
int,
unsigned char const*,
int,
snumber*);
5121template void add_coef_times_dense<unsigned int>(
unsigned int*,
int,
unsigned int const*,
int,
snumber*);
5122template void add_coef_times_dense<unsigned short>(
unsigned short*,
int,
unsigned short const*,
int,
snumber*);
5126template void add_dense<unsigned char>(
unsigned char*,
int,
unsigned char const*,
int);
5127template void add_dense<unsigned int>(
unsigned int*,
int,
unsigned int const*,
int);
5128template void add_dense<unsigned short>(
unsigned short*,
int,
unsigned short const*,
int);
5134template void sub_dense<unsigned char>(
unsigned char*,
int,
unsigned char const*,
int);
5135template void sub_dense<unsigned int>(
unsigned int*,
int,
unsigned int const*,
int);
5136template void sub_dense<unsigned short>(
unsigned short*,
int,
unsigned short const*,
int);
5140template void write_coef_idx_to_buffer_dense<unsigned char>(
CoefIdx<unsigned char>*,
int&,
unsigned char*,
int);
5141template void write_coef_idx_to_buffer_dense<unsigned int>(
CoefIdx<unsigned int>*,
int&,
unsigned int*,
int);
5142template void write_coef_idx_to_buffer_dense<unsigned short>(
CoefIdx<unsigned short>*,
int&,
unsigned short*,
int);
5143template void write_coef_idx_to_buffer<unsigned char>(
CoefIdx<unsigned char>*,
int&,
int*,
unsigned char*,
int);
5144template void write_coef_idx_to_buffer<unsigned int>(
CoefIdx<unsigned int>*,
int&,
int*,
unsigned int*,
int);
5145template void write_coef_idx_to_buffer<unsigned short>(
CoefIdx<unsigned short>*,
int&,
int*,
unsigned short*,
int);
5152template void write_minus_coef_idx_to_buffer_dense<unsigned char>(
CoefIdx<unsigned char>*,
int&,
unsigned char*,
int);
5153template void write_minus_coef_idx_to_buffer_dense<unsigned int>(
CoefIdx<unsigned int>*,
int&,
unsigned int*,
int);
5154template void write_minus_coef_idx_to_buffer_dense<unsigned short>(
CoefIdx<unsigned short>*,
int&,
unsigned short*,
int);
5155template void write_minus_coef_idx_to_buffer<unsigned char>(
CoefIdx<unsigned char>*,
int&,
int*,
unsigned char*,
int);
5156template void write_minus_coef_idx_to_buffer<unsigned int>(
CoefIdx<unsigned int>*,
int&,
int*,
unsigned int*,
int);
5157template void write_minus_coef_idx_to_buffer<unsigned short>(
CoefIdx<unsigned short>*,
int&,
int*,
unsigned short*,
int);
5160template class std::vector<DataNoroCacheNode<unsigned char>*>;
5161template class std::vector<DataNoroCacheNode<unsigned int>*>;
5162template class std::vector<DataNoroCacheNode<unsigned short>*>;
5163template 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)
poly lookup(poly term, BOOLEAN &succ, int &len)
DataNoroCacheNode< number_type > * insertAndTransferOwnerShip(poly t, ring)
DataNoroCacheNode< number_type > * insert(poly term, poly nf, int len)
static const int backLinkCode
poly_tree_node * top_level
wlen_type initial_quality
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 hat all occuring red_objects have same lm, and all occ. lm's in r[l...u] are the same,...
virtual void pre_reduce(red_object *r, int l, int u)
virtual void reduce(red_object *r, int l, int u)
we assume hat all occuring red_objects have same lm, and all occ. lm's in r[l...u] are the same,...
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
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
void sort(CFArray &A, int l=0)
quick sort A
#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, 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)
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)
static void nc_kBucketPolyRed_Z(kBucket_pt b, poly p, number *c)
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[]
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 omTypeAllocBin(type, addr, bin)
#define omFreeBinAddr(addr)
#define omSizeWOfBin(bin_ptr)
#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)
#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 unsigned pLength(poly a)
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 int rBlocks(ring r)
static BOOLEAN rField_is_Zp(const ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
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)
void simplest_gauss_modp(number_type *a, int nrows, int ncols)
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 noro_step(poly *p, int &pn, slimgb_alg *c)