My Project
Data Structures | Macros | Functions | Variables
tgb.cc File Reference
#include "kernel/mod2.h"
#include "kernel/GBEngine/tgb.h"
#include "kernel/GBEngine/tgb_internal.h"
#include "kernel/GBEngine/tgbgauss.h"
#include "misc/options.h"
#include "kernel/digitech.h"
#include "polys/nc/nc.h"
#include "polys/nc/sca.h"
#include "polys/prCopy.h"
#include "coeffs/longrat.h"
#include <stdlib.h>
#include <stdio.h>
#include <queue>

Go to the source code of this file.

Data Structures

class  poly_tree_node
 
class  exp_number_builder
 

Macros

#define BUCKETS_FOR_NORO_RED   1
 @TODO: delay nur auf Sugarvergroesserung @TODO: grade aus ecartS, setze dazu strat->honey; und nutze p.ecart @TODO: no tail reductions in syz comp More...
 
#define SR_HDL(A)   ((long)(A))
 
#define ADD_LATER_SIZE   500
 
#define LEN_VAR3
 
#define degbound(p)   assume(pTotaldegree(p)<10)
 
#define ENLARGE(pointer, type)   pointer=(type*) omrealloc(pointer, c->array_lengths*sizeof(type))
 
#define ENLARGE_ALIGN(pointer, type)
 

Functions

static int add_to_reductors (slimgb_alg *c, poly h, int len, int ecart, BOOLEAN simplified=FALSE)
 
static void multi_reduction (red_object *los, int &losl, slimgb_alg *c)
 
static void multi_reduce_step (find_erg &erg, red_object *r, slimgb_alg *c)
 
static BOOLEAN extended_product_criterion (poly p1, poly gcd1, poly p2, poly gcd2, slimgb_alg *c)
 
static poly gcd_of_terms (poly p, ring r)
 
static int tgb_pair_better_gen (const void *ap, const void *bp)
 
static BOOLEAN pair_better (sorted_pair_node *a, sorted_pair_node *b, slimgb_alg *c=NULL)
 
static BOOLEAN state_is (calc_state state, const int &i, const int &j, slimgb_alg *c)
 
static void super_clean_top_of_pair_list (slimgb_alg *c)
 
static int simple_posInS (kStrategy strat, poly p, int len, wlen_type wlen)
 
static int * make_connections (int from, int to, poly bound, slimgb_alg *c)
 
static BOOLEAN has_t_rep (const int &arg_i, const int &arg_j, slimgb_alg *state)
 
static void shorten_tails (slimgb_alg *c, poly monom)
 
static poly redNF2 (poly h, slimgb_alg *c, int &len, number &m, int n=0)
 
static poly redNFTail (poly h, const int sl, kStrategy strat, int len)
 
static int bucket_guess (kBucket *bucket)
 
static void simplify_poly (poly p, ring r)
 
int slim_nsize (number n, ring r)
 
static BOOLEAN monomial_root (poly m, ring r)
 
static BOOLEAN polynomial_root (poly h, ring r)
 
static poly p_Init_Special (const ring r)
 
static poly pOne_Special (const ring r=currRing)
 
static wlen_type pSLength (poly p, int l)
 
wlen_type kSBucketLength (kBucket *b, poly lm=NULL)
 TODO CoefBuckets bercksichtigen. More...
 
static BOOLEAN elength_is_normal_length (poly p, slimgb_alg *c)
 
static BOOLEAN lies_in_last_dp_block (poly p, slimgb_alg *c)
 
static int get_last_dp_block_start (ring r)
 
static wlen_type do_pELength (poly p, slimgb_alg *c, int dlm=-1)
 
wlen_type pELength (poly p, slimgb_alg *c, ring)
 
wlen_type kEBucketLength (kBucket *b, poly lm, slimgb_alg *ca)
 
static int pELength (poly p, slimgb_alg *c, int l)
 
static wlen_type pQuality (poly p, slimgb_alg *c, int l=-1)
 
static int pTotaldegree_full (poly p)
 
static int red_object_better_gen (const void *ap, const void *bp)
 
int tgb_pair_better_gen2 (const void *ap, const void *bp)
 
int kFindDivisibleByInS_easy (kStrategy strat, const red_object &obj)
 
int kFindDivisibleByInS_easy (kStrategy strat, poly p, long sev)
 
static int posInPairs (sorted_pair_node **p, int pn, sorted_pair_node *qe, slimgb_alg *c, int an=0)
 
static BOOLEAN ascending (int *i, int top)
 
sorted_pair_node ** spn_merge (sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
 
static BOOLEAN trivial_syzygie (int pos1, int pos2, poly bound, slimgb_alg *c)
 
int find_best (red_object *r, int l, int u, wlen_type &w, slimgb_alg *c)
 returns position sets w as weight More...
 
BOOLEAN good_has_t_rep (int i, int j, slimgb_alg *c)
 
BOOLEAN lenS_correct (kStrategy strat)
 
static void cleanS (kStrategy strat, slimgb_alg *c)
 
static void length_one_crit (slimgb_alg *c, int pos, int len)
 
static void move_forward_in_S (int old_pos, int new_pos, kStrategy strat)
 
static void move_backward_in_S (int old_pos, int new_pos, kStrategy strat)
 
static void replace_pair (int &i, int &j, slimgb_alg *c)
 
static void add_later (poly p, const char *prot, slimgb_alg *c)
 
static void clearS (poly p, unsigned long p_sev, int l, int *at, int *k, kStrategy strat)
 
static int iq_crit (const void *ap, const void *bp)
 
static wlen_type coeff_mult_size_estimate (int s1, int s2, ring r)
 
static wlen_type pair_weighted_length (int i, int j, slimgb_alg *c)
 
sorted_pair_node ** add_to_basis_ideal_quotient (poly h, slimgb_alg *c, int *ip)
 
static poly redTailShort (poly h, kStrategy strat)
 
static void line_of_extended_prod (int fixpos, slimgb_alg *c)
 
static void c_S_element_changed_hook (int pos, slimgb_alg *c)
 
BOOLEAN is_valid_ro (red_object &ro)
 
int terms_sort_crit (const void *a, const void *b)
 
static void mass_add (poly *p, int pn, slimgb_alg *c)
 
static void go_on (slimgb_alg *c)
 
void init_with_mac_poly (tgb_sparse_matrix *mat, int row, mac_poly m)
 
poly free_row_to_poly (tgb_sparse_matrix *mat, int row, poly *monoms, int monom_index)
 
static int poly_crit (const void *ap1, const void *ap2)
 
ideal t_rep_gb (const ring r, ideal arg_I, int syz_comp, BOOLEAN F4_mode)
 
ideal do_t_rep_gb (ring, ideal arg_I, int syz_comp, BOOLEAN F4_mode, int deg_pos)
 
void now_t_rep (const int &arg_i, const int &arg_j, slimgb_alg *c)
 
sorted_pair_nodetop_pair (slimgb_alg *c)
 
sorted_pair_nodequick_pop_pair (slimgb_alg *c)
 
void clean_top_of_pair_list (slimgb_alg *c)
 
void free_sorted_pair_node (sorted_pair_node *s, const ring r)
 
static BOOLEAN pHasNotCFExtended (poly p1, poly p2, poly m)
 
static wlen_type quality_of_pos_in_strat_S (int pos, slimgb_alg *c)
 
static wlen_type quality_of_pos_in_strat_S_mult_high (int pos, poly high, slimgb_alg *c)
 
static void multi_reduction_lls_trick (red_object *los, int, slimgb_alg *c, find_erg &erg)
 
static int fwbw (red_object *los, int i)
 
static void canonicalize_region (red_object *los, int l, int u, slimgb_alg *)
 
static void multi_reduction_find (red_object *los, int, slimgb_alg *c, int startf, find_erg &erg)
 
static int multi_reduction_clear_zeroes (red_object *los, int losl, int l, int u)
 
int search_red_object_pos (red_object *a, int top, red_object *key)
 
static void sort_region_down (red_object *los, int l, int u, slimgb_alg *)
 

Variables

static const int bundle_size = 100
 
static const int bundle_size_noro = 10000
 
static const int delay_factor = 3
 
STATIC_VAR omBin lm_bin = NULL
 

Macro Definition Documentation

◆ ADD_LATER_SIZE

#define ADD_LATER_SIZE   500

Definition at line 39 of file tgb.cc.

◆ BUCKETS_FOR_NORO_RED

#define BUCKETS_FOR_NORO_RED   1

@TODO: delay nur auf Sugarvergroesserung @TODO: grade aus ecartS, setze dazu strat->honey; und nutze p.ecart @TODO: no tail reductions in syz comp

Definition at line 34 of file tgb.cc.

◆ degbound

#define degbound (   p)    assume(pTotaldegree(p)<10)

Definition at line 153 of file tgb.cc.

◆ ENLARGE

#define ENLARGE (   pointer,
  type 
)    pointer=(type*) omrealloc(pointer, c->array_lengths*sizeof(type))

◆ ENLARGE_ALIGN

#define ENLARGE_ALIGN (   pointer,
  type 
)
Value:
{if(pointer)\
pointer=(type*)omReallocAligned(pointer, c->array_lengths*sizeof(type));\
else pointer=(type*)omAllocAligned(c->array_lengths*sizeof(type));}
#define omReallocAligned
Definition: omAllocDecl.h:283
#define omAllocAligned
Definition: omAllocDecl.h:273

◆ LEN_VAR3

#define LEN_VAR3

Definition at line 152 of file tgb.cc.

◆ SR_HDL

#define SR_HDL (   A)    ((long)(A))

Definition at line 35 of file tgb.cc.

Function Documentation

◆ add_later()

static void add_later ( poly  p,
const char *  prot,
slimgb_alg c 
)
static

Definition at line 1292 of file tgb.cc.

1293{
1294 int i = 0;
1295 //check, if it is already in the queue
1296
1297 while(c->add_later->m[i] != NULL)
1298 {
1299 if(p_LmEqual (c->add_later->m[i], p, c->r))
1300 return;
1301 i++;
1302 }
1303 if(TEST_OPT_PROT)
1304 PrintS (prot);
1305 c->add_later->m[i] = p;
1306}
#define NULL
Definition: auxiliary.h:104
int i
Definition: cfEzgcd.cc:132
int p
Definition: cfModGcd.cc:4080
ideal add_later
Definition: tgb_internal.h:215
#define TEST_OPT_PROT
Definition: options.h:103
#define p_LmEqual(p1, p2, r)
Definition: p_polys.h:1691
void PrintS(const char *s)
Definition: reporter.cc:284

◆ add_to_basis_ideal_quotient()

sorted_pair_node ** add_to_basis_ideal_quotient ( poly  h,
slimgb_alg c,
int *  ip 
)

Definition at line 1426 of file tgb.cc.

1428{
1429 p_Test (h, c->r);
1430 assume (h != NULL);
1431 poly got = gcd_of_terms (h, c->r);
1432 if((got != NULL) && (TEST_V_UPTORADICAL))
1433 {
1434 poly copy = p_Copy (got, c->r);
1435 //p_wrp(got,c->r);
1436 BOOLEAN changed = monomial_root (got, c->r);
1437 if(changed)
1438 {
1439 poly div_by = pMDivide (copy, got);
1440 poly iter = h;
1441 while(iter)
1442 {
1443 pExpVectorSub (iter, div_by);
1444 pIter (iter);
1445 }
1446 p_Delete (&div_by, c->r);
1447 PrintS ("U");
1448 }
1449 p_Delete (&copy, c->r);
1450 }
1451
1452#define ENLARGE(pointer, type) pointer=(type*) omrealloc(pointer, c->array_lengths*sizeof(type))
1453
1454#define ENLARGE_ALIGN(pointer, type) {if(pointer)\
1455 pointer=(type*)omReallocAligned(pointer, c->array_lengths*sizeof(type));\
1456 else pointer=(type*)omAllocAligned(c->array_lengths*sizeof(type));}
1457// BOOLEAN corr=lenS_correct(c->strat);
1458 int sugar;
1459 int ecart = 0;
1460 ++(c->n);
1461 ++(c->S->ncols);
1462 int i, j;
1463 i = c->n - 1;
1464 sorted_pair_node **nodes =
1465 (sorted_pair_node **) omalloc (sizeof (sorted_pair_node *) * i);
1466 int spc = 0;
1467 if(c->n > c->array_lengths)
1468 {
1469 c->array_lengths = c->array_lengths * 2;
1470 assume (c->array_lengths >= c->n);
1471 ENLARGE (c->T_deg, int);
1472 ENLARGE_ALIGN (c->tmp_pair_lm, poly);
1474
1475 ENLARGE_ALIGN (c->short_Exps, long);
1476 ENLARGE (c->lengths, int);
1477#ifndef HAVE_BOOST
1478#ifndef USE_STDVECBOOL
1479
1480 ENLARGE_ALIGN (c->states, char *);
1481#endif
1482#endif
1483 ENLARGE_ALIGN (c->gcd_of_terms, poly);
1484 //if (c->weighted_lengths!=NULL) {
1486 //}
1487 //ENLARGE_ALIGN(c->S->m,poly);
1488 }
1489 pEnlargeSet (&c->S->m, c->n - 1, 1);
1490 if(c->T_deg_full)
1491 ENLARGE (c->T_deg_full, int);
1492 sugar = c->T_deg[i] = c->pTotaldegree (h);
1493 if(c->T_deg_full)
1494 {
1495 sugar = c->T_deg_full[i] = c->pTotaldegree_full (h);
1496 ecart = sugar - c->T_deg[i];
1497 assume (ecart >= 0);
1498 }
1499 c->tmp_pair_lm[i] = pOne_Special (c->r);
1500
1501 c->tmp_spn[i] = (sorted_pair_node *) omAlloc (sizeof (sorted_pair_node));
1502
1503 c->lengths[i] = pLength (h);
1504
1505 //necessary for correct weighted length
1506
1508 {
1509 p_Cleardenom (h, c->r); //includes p_Content(h,c->r);
1510 }
1511 else
1512 pNorm (h);
1513 //pNormalize (h);
1514
1515 c->weighted_lengths[i] = pQuality (h, c, c->lengths[i]);
1516 c->gcd_of_terms[i] = got;
1517#ifdef HAVE_BOOST
1518 c->states.push_back (dynamic_bitset <> (i));
1519
1520#else
1521#ifdef USE_STDVECBOOL
1522
1523 c->states.push_back (vector < bool > (i));
1524
1525#else
1526 if(i > 0)
1527 c->states[i] = (char *) omAlloc (i * sizeof (char));
1528 else
1529 c->states[i] = NULL;
1530#endif
1531#endif
1532
1533 c->S->m[i] = h;
1534 c->short_Exps[i] = p_GetShortExpVector (h, c->r);
1535
1536#undef ENLARGE
1537#undef ENLARGE_ALIGN
1538 if(p_GetComp (h, currRing) <= c->syz_comp)
1539 {
1540 for(j = 0; j < i; j++)
1541 {
1542
1543
1544#ifndef HAVE_BOOST
1545 c->states[i][j] = UNCALCULATED;
1546#endif
1547 assume (p_LmDivisibleBy (c->S->m[i], c->S->m[j], c->r) ==
1548 p_LmShortDivisibleBy (c->S->m[i], c->short_Exps[i], c->S->m[j],
1549 ~(c->short_Exps[j]), c->r));
1550
1551 if(__p_GetComp (c->S->m[i], c->r) != __p_GetComp (c->S->m[j], c->r))
1552 {
1553 //c->states[i][j]=UNCALCULATED;
1554 //WARNUNG: be careful
1555 continue;
1556 }
1557 else if((!c->nc) && (c->lengths[i] == 1) && (c->lengths[j] == 1))
1558 {
1559 c->states[i][j] = HASTREP;
1560 }
1561 else if(((!c->nc) || (c->is_homog && rIsSCA (c->r)))
1562 && (pHasNotCF (c->S->m[i], c->S->m[j])))
1563// else if ((!(c->nc)) && (pHasNotCF(c->S->m[i],c->S->m[j])))
1564 {
1565 c->easy_product_crit++;
1566 c->states[i][j] = HASTREP;
1567 continue;
1568 }
1569 else
1571 (c->S->m[i], c->gcd_of_terms[i], c->S->m[j], c->gcd_of_terms[j],
1572 c))
1573 {
1574 c->states[i][j] = HASTREP;
1576 //PrintS("E");
1577 }
1578 // if (c->states[i][j]==UNCALCULATED)
1579 // {
1580
1581 if((TEST_V_FINDMONOM) && (!c->nc))
1582 {
1583 //PrintS("COMMU");
1584 // if (c->lengths[i]==c->lengths[j])
1585 // {
1586// poly short_s=ksCreateShortSpoly(c->S->m[i],c->S->m[j],c->r);
1587// if (short_s==NULL)
1588// {
1589// c->states[i][j]=HASTREP;
1590// }
1591// else
1592// {
1593// p_Delete(&short_s, currRing);
1594// }
1595// }
1596 if(c->lengths[i] + c->lengths[j] == 3)
1597 {
1598
1599
1600 poly short_s = ksCreateShortSpoly (c->S->m[i], c->S->m[j], c->r);
1601 if(short_s == NULL)
1602 {
1603 c->states[i][j] = HASTREP;
1604 }
1605 else
1606 {
1607 assume (pLength (short_s) == 1);
1609 monomial_root (short_s, c->r);
1610 int iS = kFindDivisibleByInS_easy (c->strat, short_s,
1611 p_GetShortExpVector (short_s,
1612 c->r));
1613 if(iS < 0)
1614 {
1615 //PrintS("N");
1616 if(TRUE)
1617 {
1618 c->states[i][j] = HASTREP;
1619 add_later (short_s, "N", c);
1620 }
1621 else
1622 p_Delete (&short_s, currRing);
1623 }
1624 else
1625 {
1626 if(c->strat->lenS[iS] > 1)
1627 {
1628 //PrintS("O");
1629 if(TRUE)
1630 {
1631 c->states[i][j] = HASTREP;
1632 add_later (short_s, "O", c);
1633 }
1634 else
1635 p_Delete (&short_s, currRing);
1636 }
1637 else
1638 p_Delete (&short_s, currRing);
1639 c->states[i][j] = HASTREP;
1640 }
1641
1642
1643 }
1644 }
1645 }
1646 // if (short_s)
1647 // {
1648 assume (spc <= j);
1649 sorted_pair_node *s = c->tmp_spn[spc]; //(sorted_pair_node*) omalloc(sizeof(sorted_pair_node));
1650 s->i = si_max (i, j);
1651 s->j = si_min (i, j);
1652 assume (s->j == j);
1653 s->expected_length = pair_weighted_length (i, j, c); //c->lengths[i]+c->lengths[j]-2;
1654
1655 poly lm = c->tmp_pair_lm[spc]; //=pOne_Special();
1656
1657 pLcm (c->S->m[i], c->S->m[j], lm);
1658 pSetm (lm);
1659 p_Test (lm, c->r);
1660 s->deg = c->pTotaldegree (lm);
1661
1662 if(c->T_deg_full) //Sugar
1663 {
1664 int t_i = c->T_deg_full[s->i] - c->T_deg[s->i];
1665 int t_j = c->T_deg_full[s->j] - c->T_deg[s->j];
1666 s->deg += si_max (t_i, t_j);
1667 //Print("\n max: %d\n",max(t_i,t_j));
1668 }
1669 p_Test (lm, c->r);
1670 s->lcm_of_lm = lm;
1671 // pDelete(&short_s);
1672 //assume(lm!=NULL);
1673 nodes[spc] = s;
1674 spc++;
1675
1676 // }
1677 //else
1678 //{
1679 //c->states[i][j]=HASTREP;
1680 //}
1681 }
1682 } //if syz_comp end
1683
1684 assume (spc <= i);
1685 //now ideal quotient crit
1686 qsort (nodes, spc, sizeof (sorted_pair_node *), iq_crit);
1687
1688 sorted_pair_node **nodes_final =
1689 (sorted_pair_node **) omalloc (sizeof (sorted_pair_node *) * (i+1));
1690 int spc_final = 0;
1691 j = 0;
1692 while(j < spc)
1693 {
1694 int lower = j;
1695 int upper;
1696 BOOLEAN has = FALSE;
1697 for(upper = lower + 1; upper < spc; upper++)
1698 {
1699 if(!pLmEqual (nodes[lower]->lcm_of_lm, nodes[upper]->lcm_of_lm))
1700 {
1701 break;
1702 }
1703 if(has_t_rep (nodes[upper]->i, nodes[upper]->j, c))
1704 has = TRUE;
1705 }
1706 upper = upper - 1;
1707 int z;
1708 assume (spc_final <= j);
1709 for(z = 0; z < spc_final; z++)
1710 {
1712 (nodes_final[z]->lcm_of_lm, nodes[lower]->lcm_of_lm, c->r))
1713 {
1714 has = TRUE;
1715 break;
1716 }
1717 }
1718
1719 if(has)
1720 {
1721 for(; lower <= upper; lower++)
1722 {
1723 //free_sorted_pair_node(nodes[lower],c->r);
1724 //omfree(nodes[lower]);
1725 nodes[lower] = NULL;
1726 }
1727 j = upper + 1;
1728 continue;
1729 }
1730 else
1731 {
1732 p_Test (nodes[lower]->lcm_of_lm, c->r);
1733 nodes[lower]->lcm_of_lm = pCopy (nodes[lower]->lcm_of_lm);
1734 assume (__p_GetComp (c->S->m[nodes[lower]->i], c->r) ==
1735 __p_GetComp (c->S->m[nodes[lower]->j], c->r));
1736 nodes_final[spc_final] =
1738
1739 *(nodes_final[spc_final++]) = *(nodes[lower]);
1740 //c->tmp_spn[nodes[lower]->j]=(sorted_pair_node*) omalloc(sizeof(sorted_pair_node));
1741 nodes[lower] = NULL;
1742 for(lower = lower + 1; lower <= upper; lower++)
1743 {
1744 // free_sorted_pair_node(nodes[lower],c->r);
1745 //omfree(nodes[lower]);
1746 nodes[lower] = NULL;
1747 }
1748 j = upper + 1;
1749 continue;
1750 }
1751 }
1752
1753 // Print("i:%d,spc_final:%d",i,spc_final);
1754
1755 assume (spc_final <= spc);
1756 omFree (nodes);
1757 nodes = NULL;
1758
1759 add_to_reductors (c, h, c->lengths[c->n - 1], ecart, TRUE);
1760 //i=posInS(c->strat,c->strat->sl,h,0 ecart);
1761 if(!(c->nc))
1762 {
1763 if(c->lengths[c->n - 1] == 1)
1764 shorten_tails (c, c->S->m[c->n - 1]);
1765 }
1766 //you should really update c->lengths, c->strat->lenS, and the oder of polys in strat if you sort after lengths
1767
1768 //for(i=c->strat->sl; i>0;i--)
1769 // if(c->strat->lenS[i]<c->strat->lenS[i-1]) printf("fehler bei %d\n",i);
1770 if(c->Rcounter > 50)
1771 {
1772 c->Rcounter = 0;
1773 cleanS (c->strat, c);
1774 }
1775
1776#ifdef HAVE_PLURAL
1777 // for SCA:
1778 // here write at the end of nodes_final[spc_final,...,spc_final+lmdeg-1]
1779 if(rIsSCA (c->r))
1780 {
1781 const poly pNext = pNext (h);
1782
1783 if(pNext != NULL)
1784 {
1785 // for additional polynomials
1786 const unsigned int m_iFirstAltVar = scaFirstAltVar (c->r);
1787 const unsigned int m_iLastAltVar = scaLastAltVar (c->r);
1788
1789 int N = // c->r->N;
1790 m_iLastAltVar - m_iFirstAltVar + 1; // should be enough
1791 // TODO: but we may also use got = gcd({m}_{m\in f}))!
1792
1793 poly *array_arg = (poly *) omalloc (N * sizeof (poly)); // !
1794 int j = 0;
1795
1796
1797 for(unsigned short v = m_iFirstAltVar; v <= m_iLastAltVar; v++)
1798 // for all x_v | Ann(lm(h))
1799 if(p_GetExp (h, v, c->r)) // TODO: use 'got' here!
1800 {
1801 assume (p_GetExp (h, v, c->r) == 1);
1802
1803 poly p = sca_pp_Mult_xi_pp (v, pNext, c->r); // x_v * h;
1804
1805 if(p != NULL) // if (x_v * h != 0)
1806 array_arg[j++] = p;
1807 } // for all x_v | Ann(lm(h))
1808
1809 c->introduceDelayedPairs (array_arg, j);
1810
1811 omFree (array_arg); // !!!
1812 }
1813// PrintS("Saturation - done!!!\n");
1814 }
1815#endif // if SCAlgebra
1816
1817
1818 if(!ip)
1819 {
1820 qsort (nodes_final, spc_final, sizeof (sorted_pair_node *),
1822
1823
1824 c->apairs =
1825 spn_merge (c->apairs, c->pair_top + 1, nodes_final, spc_final, c);
1826 c->pair_top += spc_final;
1828 omFree (nodes_final);
1829 return NULL;
1830 }
1831 {
1832 *ip = spc_final;
1833 return nodes_final;
1834 }
1835}
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
intset lenS
Definition: kutil.h:320
unsigned long pTotaldegree(poly p)
Definition: tgb_internal.h:275
sorted_pair_node ** apairs
Definition: tgb_internal.h:230
BOOLEAN nc
Definition: tgb_internal.h:271
kStrategy strat
Definition: tgb_internal.h:221
int * T_deg_full
Definition: tgb_internal.h:223
int array_lengths
Definition: tgb_internal.h:250
int easy_product_crit
Definition: tgb_internal.h:257
int * lengths
Definition: tgb_internal.h:218
int extended_product_crit
Definition: tgb_internal.h:258
sorted_pair_node ** tmp_spn
Definition: tgb_internal.h:226
void introduceDelayedPairs(poly *pa, int s)
Definition: tgb.cc:3184
char ** states
Definition: tgb_internal.h:210
poly * gcd_of_terms
Definition: tgb_internal.h:228
poly * tmp_pair_lm
Definition: tgb_internal.h:225
long * short_Exps
Definition: tgb_internal.h:220
BOOLEAN is_homog
Definition: tgb_internal.h:267
int syz_comp
array_lengths should be greater equal n;
Definition: tgb_internal.h:249
int pTotaldegree_full(poly p)
Definition: tgb_internal.h:283
wlen_type * weighted_lengths
Definition: tgb_internal.h:219
CFFListIterator iter
Definition: facAbsBiFact.cc:53
const CanonicalForm int s
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
CFArray copy(const CFList &list)
write elements of list into an array
int j
Definition: facHensel.cc:110
STATIC_VAR Poly * h
Definition: janet.cc:971
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:1415
int64 wlen_type
Definition: kutil.h:54
static bool rIsSCA(const ring r)
Definition: nc.h:190
poly sca_pp_Mult_xi_pp(short i, const poly pPoly, const ring rRing)
Definition: sca.cc:1203
#define assume(x)
Definition: mod2.h:387
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIter(p)
Definition: monomials.h:37
#define pNext(p)
Definition: monomials.h:36
#define __p_GetComp(p, r)
Definition: monomials.h:63
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omalloc(size)
Definition: omAllocDecl.h:228
#define omFree(addr)
Definition: omAllocDecl.h:261
#define TEST_OPT_INTSTRATEGY
Definition: options.h:110
#define TEST_V_FINDMONOM
Definition: options.h:142
#define TEST_V_UPTORADICAL
Definition: options.h:141
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition: p_polys.cc:4809
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2900
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3766
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1897
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1863
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:861
static unsigned pLength(poly a)
Definition: p_polys.h:191
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:812
#define p_Test(p, r)
Definition: p_polys.h:162
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define pSetm(p)
Definition: polys.h:271
#define pHasNotCF(p1, p2)
Definition: polys.h:263
#define pLmEqual(p1, p2)
Definition: polys.h:111
#define pExpVectorSub(p1, p2)
Definition: polys.h:88
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:363
#define pMDivide(a, b)
Definition: polys.h:293
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
#define pLcm(a, b, m)
Definition: polys.h:295
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18
static void shorten_tails(slimgb_alg *c, poly monom)
Definition: tgb.cc:3759
static poly gcd_of_terms(poly p, ring r)
Definition: tgb.cc:4065
static int add_to_reductors(slimgb_alg *c, poly h, int len, int ecart, BOOLEAN simplified=FALSE)
Definition: tgb.cc:965
int tgb_pair_better_gen2(const void *ap, const void *bp)
Definition: tgb.cc:680
sorted_pair_node ** spn_merge(sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
Definition: tgb.cc:751
static wlen_type pair_weighted_length(int i, int j, slimgb_alg *c)
Definition: tgb.cc:1373
void clean_top_of_pair_list(slimgb_alg *c)
Definition: tgb.cc:3965
#define ENLARGE(pointer, type)
static BOOLEAN monomial_root(poly m, ring r)
Definition: tgb.cc:89
#define ENLARGE_ALIGN(pointer, type)
int kFindDivisibleByInS_easy(kStrategy strat, const red_object &obj)
Definition: tgb.cc:685
static int iq_crit(const void *ap, const void *bp)
Definition: tgb.cc:1340
static void add_later(poly p, const char *prot, slimgb_alg *c)
Definition: tgb.cc:1292
static poly pOne_Special(const ring r=currRing)
Definition: tgb.cc:142
static void cleanS(kStrategy strat, slimgb_alg *c)
Definition: tgb.cc:919
static wlen_type pQuality(poly p, slimgb_alg *c, int l=-1)
Definition: tgb.cc:544
static BOOLEAN has_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *state)
Definition: tgb.cc:3726
static BOOLEAN extended_product_criterion(poly p1, poly gcd1, poly p2, poly gcd2, slimgb_alg *c)
Definition: tgb.cc:4124
@ UNCALCULATED
Definition: tgb_internal.h:313
@ HASTREP
Definition: tgb_internal.h:314

◆ add_to_reductors()

static int add_to_reductors ( slimgb_alg c,
poly  h,
int  len,
int  ecart,
BOOLEAN  simplified = FALSE 
)
static

Definition at line 965 of file tgb.cc.

967{
968 //inDebug(h);
970 assume (len == pLength (h));
971 int i;
972// if (c->isDifficultField)
973// i=simple_posInS(c->strat,h,pSLength(h,len),c->isDifficultField);
974// else
975// i=simple_posInS(c->strat,h,len,c->isDifficultField);
976
977 LObject P;
978 memset (&P, 0, sizeof (P));
979 P.tailRing = c->r;
980 P.p = h; /*p_Copy(h,c->r); */
981 P.ecart = ecart;
982 P.FDeg = c->r->pFDeg (P.p, c->r);
983 if(!(simplified))
984 {
986 {
987 p_Cleardenom (P.p, c->r); //includes p_Content(P.p,c->r );
988 }
989 else
990 pNorm (P.p);
991 //pNormalize (P.p);
992 }
993 wlen_type pq = pQuality (h, c, len);
994 i = simple_posInS (c->strat, h, len, pq);
995 c->strat->enterS (P, i, c->strat, -1);
996
997 c->strat->lenS[i] = len;
998 assume (pLength (c->strat->S[i]) == c->strat->lenS[i]);
999 if(c->strat->lenSw != NULL)
1000 c->strat->lenSw[i] = pq;
1001
1002 return i;
1003}
polyset S
Definition: kutil.h:307
wlen_set lenSw
Definition: kutil.h:321
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:287
class sLObject LObject
Definition: kutil.h:58
static int simple_posInS(kStrategy strat, poly p, int len, wlen_type wlen)
Definition: tgb.cc:1308
BOOLEAN lenS_correct(kStrategy strat)
Definition: tgb.cc:907

◆ ascending()

static BOOLEAN ascending ( int *  i,
int  top 
)
static

Definition at line 742 of file tgb.cc.

743{
744 if(top < 1)
745 return TRUE;
746 if(i[top] < i[top - 1])
747 return FALSE;
748 return ascending (i, top - 1);
749}
static BOOLEAN ascending(int *i, int top)
Definition: tgb.cc:742

◆ bucket_guess()

static int bucket_guess ( kBucket bucket)
static

Definition at line 952 of file tgb.cc.

953{
954 int sum = 0;
955 int i;
956 for(i = bucket->buckets_used; i >= 0; i--)
957 {
958 if(bucket->buckets[i])
959 sum += bucket->buckets_length[i];
960 }
961 return sum;
962}

◆ c_S_element_changed_hook()

static void c_S_element_changed_hook ( int  pos,
slimgb_alg c 
)
static

Definition at line 1971 of file tgb.cc.

1972{
1973 length_one_crit (c, pos, c->lengths[pos]);
1974 if(!c->nc)
1975 line_of_extended_prod (pos, c);
1976}
static void line_of_extended_prod(int fixpos, slimgb_alg *c)
Definition: tgb.cc:1939
static void length_one_crit(slimgb_alg *c, int pos, int len)
Definition: tgb.cc:1005

◆ canonicalize_region()

static void canonicalize_region ( red_object los,
int  l,
int  u,
slimgb_alg  
)
static

Definition at line 4527 of file tgb.cc.

4528{
4529 assume (l <= u + 1);
4530 int i;
4531 for(i = l; i <= u; i++)
4532 {
4533 kBucketCanonicalize (los[i].bucket);
4534 }
4535}
int l
Definition: cfEzgcd.cc:100
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...

◆ clean_top_of_pair_list()

void clean_top_of_pair_list ( slimgb_alg c)

Definition at line 3965 of file tgb.cc.

3966{
3967 while((c->pair_top >= 0) && (c->apairs[c->pair_top]->i >= 0)
3968 &&
3969 (!state_is
3970 (UNCALCULATED, c->apairs[c->pair_top]->j, c->apairs[c->pair_top]->i,
3971 c)))
3972 {
3974 c->pair_top--;
3975 }
3976}
void free_sorted_pair_node(sorted_pair_node *s, const ring r)
Definition: tgb.cc:3998
static BOOLEAN state_is(calc_state state, const int &i, const int &j, slimgb_alg *c)
Definition: tgb.cc:3979

◆ cleanS()

static void cleanS ( kStrategy  strat,
slimgb_alg c 
)
static

Definition at line 919 of file tgb.cc.

920{
921 int i = 0;
922 LObject P;
923 while(i <= strat->sl)
924 {
925 P.p = strat->S[i];
926 P.sev = strat->sevS[i];
927 //int dummy=strat->sl;
928 //if(kFindDivisibleByInS(strat,&dummy,&P)!=i)
929 if(kFindDivisibleByInS_easy (strat, P.p, P.sev) != i)
930 {
931 deleteInS (i, strat);
932 //remember destroying poly
934 int j;
935 for(j = 0; j < c->n; j++)
936 {
937 if(c->S->m[j] == P.p)
938 {
939 found = TRUE;
940 break;
941 }
942 }
943 if(!found)
944 pDelete (&P.p);
945 //remember additional reductors
946 }
947 else
948 i++;
949 }
950}
unsigned long * sevS
Definition: kutil.h:323
bool found
Definition: facFactorize.cc:55
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:1137
#define pDelete(p_ptr)
Definition: polys.h:186

◆ clearS()

static void clearS ( poly  p,
unsigned long  p_sev,
int  l,
int *  at,
int *  k,
kStrategy  strat 
)
inlinestatic

Definition at line 1323 of file tgb.cc.

1324{
1325 assume (p_sev == pGetShortExpVector (p));
1326 if(!pLmShortDivisibleBy (p, p_sev, strat->S[*at], ~strat->sevS[*at]))
1327 return;
1328 if(l >= strat->lenS[*at])
1329 return;
1330 if(TEST_OPT_PROT)
1331 PrintS ("!");
1332 mflush ();
1333 //pDelete(&strat->S[*at]);
1334 deleteInS ((*at), strat);
1335 (*at)--;
1336 (*k)--;
1337// assume(lenS_correct(strat));
1338}
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
Definition: polys.h:146
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
Definition: polys.h:152
#define mflush()
Definition: reporter.h:58

◆ coeff_mult_size_estimate()

static wlen_type coeff_mult_size_estimate ( int  s1,
int  s2,
ring  r 
)
static

Definition at line 1365 of file tgb.cc.

1366{
1367 if(rField_is_Q (r))
1368 return s1 + s2;
1369 else
1370 return s1 * s2;
1371}
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:508

◆ do_pELength()

static wlen_type do_pELength ( poly  p,
slimgb_alg c,
int  dlm = -1 
)
static

Definition at line 446 of file tgb.cc.

447{
448 if(p == NULL)
449 return 0;
450 wlen_type s = 0;
451 poly pi = p;
452 if(dlm < 0)
453 {
454 dlm = c->pTotaldegree (p);
455 s = 1;
456 pi = p->next;
457 }
458
459 while(pi)
460 {
461 int d = c->pTotaldegree (pi);
462 if(d > dlm)
463 s += 1 + d - dlm;
464 else
465 ++s;
466 pi = pi->next;
467 }
468 return s;
469}
#define pi
Definition: libparse.cc:1145

◆ do_t_rep_gb()

ideal do_t_rep_gb ( ring  r,
ideal  arg_I,
int  syz_comp,
BOOLEAN  F4_mode,
int  deg_pos 
)

Definition at line 3650 of file tgb.cc.

3651{
3652 // Print("QlogSize(0) %d, QlogSize(1) %d,QlogSize(-2) %d, QlogSize(5) %d\n", QlogSize(nlInit(0)),QlogSize(nlInit(1)),QlogSize(nlInit(-2)),QlogSize(nlInit(5)));
3653
3654 if(TEST_OPT_PROT)
3655 if(F4_mode)
3656 PrintS ("F4 Modus\n");
3657
3658 //debug_Ideal=arg_debug_Ideal;
3659 //if (debug_Ideal) PrintS("DebugIdeal received\n");
3660 // Print("Idelems %i \n----------\n",IDELEMS(arg_I));
3661 ideal I = arg_I;
3663 if(idIs0 (I))
3664 return I;
3665 int i;
3666 for(i = 0; i < IDELEMS (I); i++)
3667 {
3668 assume (I->m[i] != NULL);
3669 simplify_poly (I->m[i], currRing);
3670 }
3671
3672 qsort (I->m, IDELEMS (I), sizeof (poly), poly_crit);
3673 //Print("Idelems %i \n----------\n",IDELEMS(I));
3674 //slimgb_alg* c=(slimgb_alg*) omalloc(sizeof(slimgb_alg));
3675 //int syz_comp=arg_I->rank;
3676 slimgb_alg *c = new slimgb_alg (I, syz_comp, F4_mode, deg_pos);
3677
3678 while((c->pair_top >= 0)
3679 && ((!(TEST_OPT_DEGBOUND))
3680 || (c->apairs[c->pair_top]->deg <= Kstd1_deg)))
3681 {
3682#ifdef HAVE_F4
3683 if(F4_mode)
3684 go_on_F4 (c);
3685 else
3686#endif
3687 go_on (c);
3688 }
3689 if(c->pair_top < 0)
3690 c->completed = TRUE;
3691 I = c->S;
3692 delete c;
3693 if(TEST_OPT_REDSB)
3694 {
3695 ideal erg = kInterRed (I, NULL);
3696 assume (I != erg);
3697 id_Delete (&I, currRing);
3698 return erg;
3699 }
3700 //qsort(I->m, IDELEMS(I),sizeof(poly),pLmCmp_func);
3701 assume (I->rank >= id_RankFreeModule (I,currRing));
3702 return (I);
3703}
BOOLEAN completed
Definition: tgb_internal.h:266
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
ideal kInterRed(ideal F, ideal Q)
Definition: kstd1.cc:3745
EXTERN_VAR int Kstd1_deg
Definition: kstd1.h:49
#define TEST_OPT_REDSB
Definition: options.h:104
#define TEST_OPT_DEGBOUND
Definition: options.h:113
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 id_Compactify(ideal id, const ring r)
#define IDELEMS(i)
Definition: simpleideals.h:23
static void go_on(slimgb_alg *c)
Definition: tgb.cc:2760
static int poly_crit(const void *ap1, const void *ap2)
Definition: tgb.cc:3166
static void simplify_poly(poly p, ring r)
Definition: tgb.cc:59

◆ elength_is_normal_length()

static BOOLEAN elength_is_normal_length ( poly  p,
slimgb_alg c 
)
static

Definition at line 371 of file tgb.cc.

372{
373 ring r = c->r;
374 if(p_GetComp (p, r) != 0)
375 return FALSE;
376 if(c->lastDpBlockStart <= (currRing->N))
377 {
378 int i;
379 for(i = 1; i < c->lastDpBlockStart; i++)
380 {
381 if(p_GetExp (p, i, r) != 0)
382 {
383 break;
384 }
385 }
386 if(i >= c->lastDpBlockStart)
387 {
388 //wrp(p);
389 //PrintS("\n");
390 return TRUE;
391 }
392 else
393 return FALSE;
394 }
395 else
396 return FALSE;
397}
int lastDpBlockStart
Definition: tgb_internal.h:260

◆ extended_product_criterion()

static BOOLEAN extended_product_criterion ( poly  p1,
poly  gcd1,
poly  p2,
poly  gcd2,
slimgb_alg c 
)
inlinestatic

Definition at line 4124 of file tgb.cc.

4126{
4127 if(c->nc)
4128 return FALSE;
4129 if(gcd1 == NULL)
4130 return FALSE;
4131 if(gcd2 == NULL)
4132 return FALSE;
4133 gcd1->next = gcd2; //may ordered incorrect
4134 poly m = gcd_of_terms (gcd1, c->r);
4135 gcd1->next = NULL;
4136 if(m == NULL)
4137 return FALSE;
4138
4139 BOOLEAN erg = pHasNotCFExtended (p1, p2, m);
4140 pDelete (&m);
4141 return erg;
4142}
int m
Definition: cfEzgcd.cc:128
static BOOLEAN pHasNotCFExtended(poly p1, poly p2, poly m)
Definition: tgb.cc:4105

◆ find_best()

int find_best ( red_object r,
int  l,
int  u,
wlen_type w,
slimgb_alg c 
)

returns position sets w as weight

Definition at line 854 of file tgb.cc.

855{
856 int best = l;
857 int i;
858 w = r[l].guess_quality (c);
859 for(i = l + 1; i <= u; i++)
860 {
861 wlen_type w2 = r[i].guess_quality (c);
862 if(w2 < w)
863 {
864 w = w2;
865 best = i;
866 }
867 }
868 return best;
869}
wlen_type guess_quality(slimgb_alg *c)
Definition: tgb.cc:591
const CanonicalForm & w
Definition: facAbsFact.cc:51

◆ free_row_to_poly()

poly free_row_to_poly ( tgb_sparse_matrix mat,
int  row,
poly *  monoms,
int  monom_index 
)

Definition at line 3146 of file tgb.cc.

3148{
3149 poly p = NULL;
3150 poly *set_this = &p;
3151 mac_poly r = mat->mp[row];
3152 mat->mp[row] = NULL;
3153 while(r)
3154 {
3155 (*set_this) = pLmInit (monoms[monom_index - 1 - r->exp]);
3156 pSetCoeff ((*set_this), r->coef);
3157 set_this = &((*set_this)->next);
3158 mac_poly old = r;
3159 r = r->next;
3160 delete old;
3161
3162 }
3163 return p;
3164}
mac_poly_r * next
Definition: tgbgauss.h:51
number coef
Definition: tgbgauss.h:50
int exp
Definition: tgbgauss.h:52
mac_poly * mp
Definition: tgbgauss.h:64
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
Definition: polys.h:64

◆ free_sorted_pair_node()

void free_sorted_pair_node ( sorted_pair_node s,
const ring  r 
)

Definition at line 3998 of file tgb.cc.

3999{
4000 if(s->i >= 0)
4001 p_Delete (&s->lcm_of_lm, r);
4002 omFree (s);
4003}

◆ fwbw()

static int fwbw ( red_object los,
int  i 
)
static

Definition at line 4469 of file tgb.cc.

4470{
4471 int i2 = i;
4472 int step = 1;
4473
4474 BOOLEAN bw = FALSE;
4475 BOOLEAN incr = TRUE;
4476
4477 while(1)
4478 {
4479 if(!bw)
4480 {
4481 step = si_min (i2, step);
4482 if(step == 0)
4483 break;
4484 i2 -= step;
4485
4486 if(!pLmEqual (los[i].p, los[i2].p))
4487 {
4488 bw = TRUE;
4489 incr = FALSE;
4490 }
4491 else
4492 {
4493 if((!incr) && (step == 1))
4494 break;
4495 }
4496 }
4497 else
4498 {
4499 step = si_min (i - i2, step);
4500 if(step == 0)
4501 break;
4502 i2 += step;
4503 if(pLmEqual (los[i].p, los[i2].p))
4504 {
4505 if(step == 1)
4506 break;
4507 else
4508 {
4509 bw = FALSE;
4510 }
4511 }
4512 }
4513 if(incr)
4514 step *= 2;
4515 else
4516 {
4517 if(step % 2 == 1)
4518 step = (step + 1) / 2;
4519 else
4520 step /= 2;
4521 }
4522 }
4523 return i2;
4524}

◆ gcd_of_terms()

static poly gcd_of_terms ( poly  p,
ring  r 
)
static

Definition at line 4065 of file tgb.cc.

4066{
4067 int max_g_0 = 0;
4068 assume (p != NULL);
4069 int i;
4070 poly m = pOne ();
4071 poly t;
4072 for(i = (currRing->N); i; i--)
4073 {
4074 pSetExp (m, i, pGetExp (p, i));
4075 if(max_g_0 == 0)
4076 if(pGetExp (m, i) > 0)
4077 max_g_0 = i;
4078 }
4079
4080 t = p->next;
4081 while(t != NULL)
4082 {
4083 if(max_g_0 == 0)
4084 break;
4085 for(i = max_g_0; i; i--)
4086 {
4087 pSetExp (m, i, si_min (pGetExp (t, i), pGetExp (m, i)));
4088 if(max_g_0 == i)
4089 if(pGetExp (m, i) == 0)
4090 max_g_0 = 0;
4091 if((max_g_0 == 0) && (pGetExp (m, i) > 0))
4092 {
4093 max_g_0 = i;
4094 }
4095 }
4096 t = t->next;
4097 }
4098 p_Setm (m, r);
4099 if(max_g_0 > 0)
4100 return m;
4101 pDelete (&m);
4102 return NULL;
4103}
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
#define pSetExp(p, i, v)
Definition: polys.h:42
#define pOne()
Definition: polys.h:315

◆ get_last_dp_block_start()

static int get_last_dp_block_start ( ring  r)
static

Definition at line 427 of file tgb.cc.

428{
429 //ring r=c->r;
430 int last_block;
431
433 {
434 last_block = rBlocks (r) - 3;
435 }
436 else
437 {
438 last_block = rBlocks (r) - 2;
439 }
440 assume (last_block >= 0);
441 if(r->order[last_block] == ringorder_dp)
442 return r->block0[last_block];
443 return (currRing->N) + 1;
444}
BOOLEAN rRing_has_CompLastBlock(const ring r)
Definition: ring.cc:5154
static int rBlocks(ring r)
Definition: ring.h:570
@ ringorder_dp
Definition: ring.h:78

◆ go_on()

static void go_on ( slimgb_alg c)
static

Definition at line 2760 of file tgb.cc.

2761{
2762 //set limit of 1000 for multireductions, at the moment for
2763 //programming reasons
2764#ifdef USE_NORO
2765 //Print("module rank%d\n",c->S->rank);
2766 const BOOLEAN use_noro = c->use_noro;
2767#else
2768 const BOOLEAN use_noro = FALSE;
2769#endif
2770 int i = 0;
2771 c->average_length = 0;
2772 for(i = 0; i < c->n; i++)
2773 {
2774 c->average_length += c->lengths[i];
2775 }
2776 c->average_length = c->average_length / c->n;
2777 i = 0;
2778 int max_pairs = bundle_size;
2779
2780#ifdef USE_NORO
2781 if((use_noro) || (c->use_noro_last_block))
2782 max_pairs = bundle_size_noro;
2783#endif
2784 poly *p = (poly *) omAlloc ((max_pairs + 1) * sizeof (poly)); //nullterminated
2785
2786 int curr_deg = -1;
2787 while(i < max_pairs)
2788 {
2789 sorted_pair_node *s = top_pair (c); //here is actually chain criterium done
2790
2791 if(!s)
2792 break;
2793
2794 if(curr_deg >= 0)
2795 {
2796 if(s->deg > curr_deg)
2797 break;
2798 }
2799
2800 else
2801 curr_deg = s->deg;
2802 quick_pop_pair (c);
2803 if(s->i >= 0)
2804 {
2805 //be careful replace_pair use createShortSpoly which is not noncommutative
2806 now_t_rep (s->i, s->j, c);
2807 replace_pair (s->i, s->j, c);
2808
2809 if(s->i == s->j)
2810 {
2812 continue;
2813 }
2814 now_t_rep (s->i, s->j, c);
2815 }
2816 poly h;
2817 if(s->i >= 0)
2818 {
2819#ifdef HAVE_PLURAL
2820 if(c->nc)
2821 {
2822 h = nc_CreateSpoly (c->S->m[s->i], c->S->m[s->j] /*, NULL */ , c->r);
2823
2824 if(h != NULL)
2825 p_Cleardenom (h, c->r);
2826 }
2827 else
2828#endif
2829 h = ksOldCreateSpoly (c->S->m[s->i], c->S->m[s->j], NULL, c->r);
2830 p_Test (h, c->r);
2831 }
2832 else
2833 {
2834 h = s->lcm_of_lm;
2835 p_Test (h, c->r);
2836 }
2837 // if(s->i>=0)
2838// now_t_rep(s->j,s->i,c);
2839 number coef;
2840 int mlen = pLength (h);
2841 p_Test (h, c->r);
2842 if((!c->nc) & (!(use_noro)))
2843 {
2844 h = redNF2 (h, c, mlen, coef, 2);
2845 redTailShort (h, c->strat);
2846 nDelete (&coef);
2847 }
2848 p_Test (h, c->r);
2850 if(!h)
2851 continue;
2852 p[i] = h;
2853 i++;
2854 }
2855 p[i] = NULL;
2856// pre_comp(p,i,c);
2857 if(i == 0)
2858 {
2859 omFree (p);
2860 return;
2861 }
2862#ifdef TGB_RESORT_PAIRS
2863 c->replaced = new bool[c->n];
2864 c->used_b = FALSE;
2865#endif
2866
2867 c->normal_forms += i;
2868 int j;
2869#ifdef USE_NORO
2870 //if ((!(c->nc))&&(rField_is_Zp(c->r)))
2871 //{
2872 if(use_noro)
2873 {
2874 int pn = i;
2875 if(pn == 0)
2876 {
2877 omFree (p);
2878 return;
2879 }
2880 {
2881 if(n_GetChar(currRing->cf) < 255)
2882 {
2883 noro_step < tgb_uint8 > (p, pn, c);
2884 }
2885 else
2886 {
2887 if(n_GetChar(currRing->cf) < 65000)
2888 {
2889 noro_step < tgb_uint16 > (p, pn, c);
2890 }
2891 else
2892 {
2893 noro_step < tgb_uint32 > (p, pn, c);
2894 }
2895 }
2896 }
2897
2898 //if (TEST_OPT_PROT)
2899 //{
2900 // Print("reported rank:%i\n",pn);
2901 //}
2902 mass_add (p, pn, c);
2903 omFree (p);
2904 return;
2905 /*if (TEST_OPT_PROT)
2906 for(j=0;j<pn;j++)
2907 {
2908 p_wrp(p[j],c->r);
2909 } */
2910 }
2911#endif
2912 red_object *buf = (red_object *) omAlloc (i * sizeof (red_object)); /*i>0*/
2913 for(j = 0; j < i; j++)
2914 {
2915 p_Test (p[j], c->r);
2916 buf[j].p = p[j];
2917 buf[j].sev = pGetShortExpVector (p[j]);
2918 buf[j].bucket = kBucketCreate (currRing);
2919 p_Test (p[j], c->r);
2920 int len = pLength (p[j]);
2921 kBucketInit (buf[j].bucket, buf[j].p, len);
2922 buf[j].initial_quality = buf[j].guess_quality (c);
2923 assume (buf[j].initial_quality >= 0);
2924 }
2925 omFree (p);
2926 qsort (buf, i, sizeof (red_object), red_object_better_gen);
2927// Print("\ncurr_deg:%i\n",curr_deg);
2928 if(TEST_OPT_PROT)
2929 {
2930 Print ("%dM[%d,", curr_deg, i);
2931 }
2932
2933 multi_reduction (buf, i, c);
2934#ifdef TGB_RESORT_PAIRS
2935 if(c->used_b)
2936 {
2937 if(TEST_OPT_PROT)
2938 PrintS ("B");
2939 int e;
2940 for(e = 0; e <= c->pair_top; e++)
2941 {
2942 if(c->apairs[e]->i < 0)
2943 continue;
2944 assume (c->apairs[e]->j >= 0);
2945 if((c->replaced[c->apairs[e]->i]) || (c->replaced[c->apairs[e]->j]))
2946 {
2947 sorted_pair_node *s = c->apairs[e];
2948 s->expected_length = pair_weighted_length (s->i, s->j, c);
2949 }
2950 }
2951 qsort (c->apairs, c->pair_top + 1, sizeof (sorted_pair_node *),
2953 }
2954#endif
2955#ifdef TGB_DEBUG
2956 {
2957 int k;
2958 for(k = 0; k < i; k++)
2959 {
2961 int k2;
2962 for(k2 = 0; k2 < i; k2++)
2963 {
2964 if(k == k2)
2965 continue;
2966 assume ((!(p_LmDivisibleBy (buf[k].p, buf[k2].p, c->r)))
2967 || (wrp (buf[k].p), Print (" k %d k2 %d ", k, k2),
2968 wrp (buf[k2].p), FALSE));
2969 }
2970 }
2971 }
2972#endif
2973 //resort S
2974
2975 if(TEST_OPT_PROT)
2976 Print ("%i]", i);
2977
2978 poly *add_those = (poly *) omalloc (i * sizeof (poly));
2979 for(j = 0; j < i; j++)
2980 {
2981 int len;
2982 poly p;
2983 buf[j].flatten ();
2984 kBucketClear (buf[j].bucket, &p, &len);
2985 kBucketDestroy (&buf[j].bucket);
2986 p_Test (p, c->r);
2987 //if (!c->nc) {
2988 if((c->tailReductions) || (lies_in_last_dp_block (p, c)))
2989 {
2990 p = redNFTail (p, c->strat->sl, c->strat, 0);
2991 }
2992 else
2993 {
2994 p = redTailShort (p, c->strat);
2995 }
2996 //}
2997 p_Test (p, c->r);
2998 add_those[j] = p;
2999
3000 //sbuf[j]=add_to_basis(p,-1,-1,c,ibuf+j);
3001 }
3002 mass_add (add_those, i, c);
3003 omFree (add_those);
3004 omFree (buf);
3005
3006 if(TEST_OPT_PROT)
3007 Print ("(%d)", c->pair_top + 1);
3008 //TODO: implement that while(!(idIs0(c->add_later)))
3009#ifdef TGB_RESORT_PAIRS
3010 delete c->replaced;
3011 c->replaced = NULL;
3012 c->used_b = FALSE;
3013#endif
3014 return;
3015}
int k
Definition: cfEzgcd.cc:99
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)
int sl
Definition: kutil.h:351
BOOLEAN use_noro_last_block
Definition: tgb_internal.h:264
int average_length
Definition: tgb_internal.h:259
BOOLEAN tailReductions
Definition: tgb_internal.h:268
BOOLEAN use_noro
Definition: tgb_internal.h:263
int normal_forms
Definition: tgb_internal.h:251
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
#define Print
Definition: emacs.cc:80
fq_nmod_t buf
Definition: facHensel.cc:101
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
Definition: kInline.h:1162
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
Definition: kbuckets.cc:521
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:216
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition: kbuckets.cc:493
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
Definition: kbuckets.cc:209
static poly nc_CreateSpoly(const poly p1, const poly p2, const ring r)
Definition: nc.h:241
#define nDelete(n)
Definition: numbers.h:16
void wrp(poly p)
Definition: polys.h:310
static poly redNFTail(poly h, const int sl, kStrategy strat, int len)
Definition: tgb.cc:3019
static const int bundle_size
Definition: tgb.cc:36
void now_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *c)
Definition: tgb.cc:3705
static void mass_add(poly *p, int pn, slimgb_alg *c)
Definition: tgb.cc:2145
static BOOLEAN lies_in_last_dp_block(poly p, slimgb_alg *c)
Definition: tgb.cc:399
sorted_pair_node * quick_pop_pair(slimgb_alg *c)
Definition: tgb.cc:3944
sorted_pair_node * top_pair(slimgb_alg *c)
Definition: tgb.cc:3920
static void replace_pair(int &i, int &j, slimgb_alg *c)
Definition: tgb.cc:1215
static poly redNF2(poly h, slimgb_alg *c, int &len, number &m, int n=0)
Definition: tgb.cc:1837
static void multi_reduction(red_object *los, int &losl, slimgb_alg *c)
Definition: tgb.cc:4722
static poly redTailShort(poly h, kStrategy strat)
Definition: tgb.cc:1920
static int red_object_better_gen(const void *ap, const void *bp)
Definition: tgb.cc:665
static const int bundle_size_noro
Definition: tgb.cc:37

◆ good_has_t_rep()

BOOLEAN good_has_t_rep ( int  i,
int  j,
slimgb_alg c 
)

Definition at line 876 of file tgb.cc.

877{
878 assume (i >= 0);
879 assume (j >= 0);
880 if(has_t_rep (i, j, c))
881 return TRUE;
882 //poly lm=pOne();
883 assume (c->tmp_lm != NULL);
884 poly lm = c->tmp_lm;
885
886 pLcm (c->S->m[i], c->S->m[j], lm);
887 pSetm (lm);
888 assume (lm != NULL);
889 //int deciding_deg= pTotaldegree(lm);
890 int *i_con = make_connections (i, j, lm, c);
891 //p_Delete(&lm,c->r);
892
893 for(int n = 0; ((n < c->n) && (i_con[n] >= 0)); n++)
894 {
895 if(i_con[n] == j)
896 {
897 now_t_rep (i, j, c);
898 omFree (i_con);
899 return TRUE;
900 }
901 }
902 omFree (i_con);
903
904 return FALSE;
905}
static int * make_connections(int from, int to, poly bound, slimgb_alg *c)
Definition: tgb.cc:1101

◆ has_t_rep()

static BOOLEAN has_t_rep ( const int &  arg_i,
const int &  arg_j,
slimgb_alg state 
)
static

Definition at line 3726 of file tgb.cc.

3727{
3728 assume (0 <= arg_i);
3729 assume (0 <= arg_j);
3730 assume (arg_i < state->n);
3731 assume (arg_j < state->n);
3732 if(arg_i == arg_j)
3733 {
3734 return (TRUE);
3735 }
3736 if(arg_i > arg_j)
3737 {
3738 return (state->states[arg_i][arg_j] == HASTREP);
3739 }
3740 else
3741 {
3742 return (state->states[arg_j][arg_i] == HASTREP);
3743 }
3744}

◆ init_with_mac_poly()

void init_with_mac_poly ( tgb_sparse_matrix mat,
int  row,
mac_poly  m 
)

Definition at line 3131 of file tgb.cc.

3132{
3133 assume (mat->mp[row] == NULL);
3134 mat->mp[row] = m;
3135#ifdef TGB_DEBUG
3136 mac_poly r = m;
3137 while(r)
3138 {
3139 assume (r->exp < mat->columns);
3140 r = r->next;
3141 }
3142#endif
3143}

◆ iq_crit()

static int iq_crit ( const void *  ap,
const void *  bp 
)
static

Definition at line 1340 of file tgb.cc.

1341{
1343 sorted_pair_node *b = *((sorted_pair_node **) bp);
1344 assume (a->i > a->j);
1345 assume (b->i > b->j);
1346
1347 if(a->deg < b->deg)
1348 return -1;
1349 if(a->deg > b->deg)
1350 return 1;
1351 int comp = pLmCmp (a->lcm_of_lm, b->lcm_of_lm);
1352 if(comp != 0)
1353 return comp;
1354 if(a->expected_length < b->expected_length)
1355 return -1;
1356 if(a->expected_length > b->expected_length)
1357 return 1;
1358 if(a->j > b->j)
1359 return 1;
1360 if(a->j < b->j)
1361 return -1;
1362 return 0;
1363}
CanonicalForm b
Definition: cfModGcd.cc:4105
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
Definition: ap.h:40
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
wlen_type expected_length
Definition: tgb_internal.h:147

◆ is_valid_ro()

BOOLEAN is_valid_ro ( red_object ro)

Definition at line 2021 of file tgb.cc.

2022{
2023 red_object r2 = ro;
2024 ro.validate ();
2025 if((r2.p != ro.p) || (r2.sev != ro.sev))
2026 return FALSE;
2027 return TRUE;
2028}
unsigned long sev
Definition: tgb_internal.h:300
void validate()
Definition: tgb.cc:4910

◆ kEBucketLength()

wlen_type kEBucketLength ( kBucket b,
poly  lm,
slimgb_alg ca 
)

Definition at line 494 of file tgb.cc.

495{
496 wlen_type s = 0;
497 if(lm == NULL)
498 {
499 lm = kBucketGetLm (b);
500 }
501 if(lm == NULL)
502 return 0;
503 if(elength_is_normal_length (lm, ca))
504 {
505 return bucket_guess (b);
506 }
507 int d = ca->pTotaldegree (lm);
508#if 0
509 assume (sugar >= d);
510 s = 1 + (bucket_guess (b) - 1) * (sugar - d + 1);
511 return s;
512#else
513
514 //int d=pTotaldegree(lm,ca->r);
515 int i;
516 for(i = b->buckets_used; i >= 0; i--)
517 {
518 if(b->buckets[i] == NULL)
519 continue;
520
521 if((ca->pTotaldegree (b->buckets[i]) <= d)
522 && (elength_is_normal_length (b->buckets[i], ca)))
523 {
524 s += b->buckets_length[i];
525 }
526 else
527 {
528 s += do_pELength (b->buckets[i], ca, d);
529 }
530 }
531 return s;
532#endif
533}
const poly kBucketGetLm(kBucket_pt bucket)
Definition: kbuckets.cc:506
static wlen_type do_pELength(poly p, slimgb_alg *c, int dlm=-1)
Definition: tgb.cc:446
static int bucket_guess(kBucket *bucket)
Definition: tgb.cc:952
static BOOLEAN elength_is_normal_length(poly p, slimgb_alg *c)
Definition: tgb.cc:371

◆ kFindDivisibleByInS_easy() [1/2]

int kFindDivisibleByInS_easy ( kStrategy  strat,
const red_object obj 
)

Definition at line 685 of file tgb.cc.

686{
687 poly p = obj.p;
688 if ((strat->syzComp>0) && (pGetComp(p)>strat->syzComp)) return -1;
689 long not_sev = ~obj.sev;
690 for(int i = 0; i <= strat->sl; i++)
691 {
692 if(pLmShortDivisibleBy (strat->S[i], strat->sevS[i], p, not_sev))
693 return i;
694 }
695 return -1;
696}
int syzComp
Definition: kutil.h:357
#define pGetComp(p)
Component.
Definition: polys.h:37

◆ kFindDivisibleByInS_easy() [2/2]

int kFindDivisibleByInS_easy ( kStrategy  strat,
poly  p,
long  sev 
)

Definition at line 698 of file tgb.cc.

699{
700 if ((strat->syzComp>0) && (pGetComp(p)>strat->syzComp)) return -1;
701 long not_sev = ~sev;
702 for(int i = 0; i <= strat->sl; i++)
703 {
704 if(pLmShortDivisibleBy (strat->S[i], strat->sevS[i], p, not_sev))
705 return i;
706 }
707 return -1;
708}

◆ kSBucketLength()

wlen_type kSBucketLength ( kBucket b,
poly  lm = NULL 
)

TODO CoefBuckets bercksichtigen.

Definition at line 221 of file tgb.cc.

222{
223 int s = 0;
224 wlen_type c;
225 number coef;
226 if(lm == NULL)
227 coef = pGetCoeff (kBucketGetLm (b));
228 //c=nSize(pGetCoeff(kBucketGetLm(b)));
229 else
230 coef = pGetCoeff (lm);
231 //c=nSize(pGetCoeff(lm));
233 {
234 c = nlQlogSize (coef, currRing->cf);
235 }
236 else
237 c = nSize (coef);
238
239 int i;
240 for(i = b->buckets_used; i >= 0; i--)
241 {
242 assume ((b->buckets_length[i] == 0) || (b->buckets[i] != NULL));
243 s += b->buckets_length[i] /*pLength(b->buckets[i]) */ ;
244 }
245#ifdef HAVE_COEF_BUCKETS
246 assume (b->buckets[0] == kBucketGetLm (b));
247 if(b->coef[0] != NULL)
248 {
250 {
251 int modifier = nlQlogSize (pGetCoeff (b->coef[0]), currRing->cf);
252 c += modifier;
253 }
254 else
255 {
256 int modifier = nSize (pGetCoeff (b->coef[0]));
257 c *= modifier;
258 }
259 }
260#endif
261 if(!(TEST_V_COEFSTRAT))
262 {
263 return s * c;
264 }
265 else
266 {
267 wlen_type res = s;
268 res *= c;
269 res *= c;
270 return res;
271 }
272}
CanonicalForm res
Definition: facAbsFact.cc:60
static FORCE_INLINE int nlQlogSize(number n, const coeffs r)
only used by slimgb (tgb.cc)
Definition: longrat.h:76
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define nSize(n)
Definition: numbers.h:39
#define TEST_V_COEFSTRAT
Definition: options.h:140

◆ length_one_crit()

static void length_one_crit ( slimgb_alg c,
int  pos,
int  len 
)
static

Definition at line 1005 of file tgb.cc.

1006{
1007 if(c->nc)
1008 return;
1009 if(len == 1)
1010 {
1011 int i;
1012 for(i = 0; i < pos; i++)
1013 {
1014 if(c->lengths[i] == 1)
1015 c->states[pos][i] = HASTREP;
1016 }
1017 for(i = pos + 1; i < c->n; i++)
1018 {
1019 if(c->lengths[i] == 1)
1020 c->states[i][pos] = HASTREP;
1021 }
1022 if(!c->nc)
1023 shorten_tails (c, c->S->m[pos]);
1024 }
1025}

◆ lenS_correct()

BOOLEAN lenS_correct ( kStrategy  strat)

Definition at line 907 of file tgb.cc.

908{
909 int i;
910 for(i = 0; i <= strat->sl; i++)
911 {
912 if(strat->lenS[i] != pLength (strat->S[i]))
913 return FALSE;
914 }
915 return TRUE;
916}

◆ lies_in_last_dp_block()

static BOOLEAN lies_in_last_dp_block ( poly  p,
slimgb_alg c 
)
static

Definition at line 399 of file tgb.cc.

400{
401 ring r = c->r;
402 if(p_GetComp (p, r) != 0)
403 return FALSE;
404 if(c->lastDpBlockStart <= (currRing->N))
405 {
406 int i;
407 for(i = 1; i < c->lastDpBlockStart; i++)
408 {
409 if(p_GetExp (p, i, r) != 0)
410 {
411 break;
412 }
413 }
414 if(i >= c->lastDpBlockStart)
415 {
416 //wrp(p);
417 //PrintS("\n");
418 return TRUE;
419 }
420 else
421 return FALSE;
422 }
423 else
424 return FALSE;
425}

◆ line_of_extended_prod()

static void line_of_extended_prod ( int  fixpos,
slimgb_alg c 
)
static

Definition at line 1939 of file tgb.cc.

1940{
1941 if(c->gcd_of_terms[fixpos] == NULL)
1942 {
1943 c->gcd_of_terms[fixpos] = gcd_of_terms (c->S->m[fixpos], c->r);
1944 if(c->gcd_of_terms[fixpos])
1945 {
1946 int i;
1947 for(i = 0; i < fixpos; i++)
1948 if((c->states[fixpos][i] != HASTREP)
1949 &&
1951 (c->S->m[fixpos], c->gcd_of_terms[fixpos], c->S->m[i],
1952 c->gcd_of_terms[i], c)))
1953 {
1954 c->states[fixpos][i] = HASTREP;
1956 }
1957 for(i = fixpos + 1; i < c->n; i++)
1958 if((c->states[i][fixpos] != HASTREP)
1959 &&
1961 (c->S->m[fixpos], c->gcd_of_terms[fixpos], c->S->m[i],
1962 c->gcd_of_terms[i], c)))
1963 {
1964 c->states[i][fixpos] = HASTREP;
1966 }
1967 }
1968 }
1969}

◆ make_connections()

static int * make_connections ( int  from,
int  to,
poly  bound,
slimgb_alg c 
)
static

Definition at line 1101 of file tgb.cc.

1102{
1103 ideal I = c->S;
1104 int *cans = (int *) omAlloc (c->n * sizeof (int));
1105 int *connected = (int *) omAlloc (c->n * sizeof (int));
1106 cans[0] = to;
1107 int cans_length = 1;
1108 connected[0] = from;
1109 int last_cans_pos = -1;
1110 int connected_length = 1;
1111 long neg_bounds_short = ~p_GetShortExpVector (bound, c->r);
1112
1113 int not_yet_found = cans_length;
1114 int con_checked = 0;
1115 int pos;
1116
1117 while(TRUE)
1118 {
1119 if((con_checked < connected_length) && (not_yet_found > 0))
1120 {
1121 pos = connected[con_checked];
1122 for(int i = 0; i < cans_length; i++)
1123 {
1124 if(cans[i] < 0)
1125 continue;
1126 //FIXME: triv. syz. does not hold on noncommutative, check it for modules
1127 if((has_t_rep (pos, cans[i], c))
1128 || ((!rIsPluralRing (c->r))
1129 && (trivial_syzygie (pos, cans[i], bound, c))))
1130 {
1131 connected[connected_length] = cans[i];
1132 connected_length++;
1133 cans[i] = -1;
1134 --not_yet_found;
1135
1136 if(connected[connected_length - 1] == to)
1137 {
1138 if(connected_length < c->n)
1139 {
1140 connected[connected_length] = -1;
1141 }
1142 omFree (cans);
1143 return connected;
1144 }
1145 }
1146 }
1147 con_checked++;
1148 }
1149 else
1150 {
1151 for(last_cans_pos++; last_cans_pos <= c->n; last_cans_pos++)
1152 {
1153 if(last_cans_pos == c->n)
1154 {
1155 if(connected_length < c->n)
1156 {
1157 connected[connected_length] = -1;
1158 }
1159 omFree (cans);
1160 return connected;
1161 }
1162 if((last_cans_pos == from) || (last_cans_pos == to))
1163 continue;
1165 (I->m[last_cans_pos], c->short_Exps[last_cans_pos], bound,
1166 neg_bounds_short, c->r))
1167 {
1168 cans[cans_length] = last_cans_pos;
1169 cans_length++;
1170 break;
1171 }
1172 }
1173 not_yet_found++;
1174 for(int i = 0; i < con_checked; i++)
1175 {
1176 if(has_t_rep (connected[i], last_cans_pos, c))
1177 {
1178 connected[connected_length] = last_cans_pos;
1179 connected_length++;
1180 cans[cans_length - 1] = -1;
1181 --not_yet_found;
1182 if(connected[connected_length - 1] == to)
1183 {
1184 if(connected_length < c->n)
1185 {
1186 connected[connected_length] = -1;
1187 }
1188 omFree (cans);
1189 return connected;
1190 }
1191 break;
1192 }
1193 }
1194 }
1195 }
1196 if(connected_length < c->n)
1197 {
1198 connected[connected_length] = -1;
1199 }
1200 omFree (cans);
1201 return connected;
1202}
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
static BOOLEAN trivial_syzygie(int pos1, int pos2, poly bound, slimgb_alg *c)
Definition: tgb.cc:800

◆ mass_add()

static void mass_add ( poly *  p,
int  pn,
slimgb_alg c 
)
static

Definition at line 2145 of file tgb.cc.

2146{
2147 int j;
2148 int *ibuf = (int *) omalloc (pn * sizeof (int));
2149 sorted_pair_node ***sbuf =
2150 (sorted_pair_node ***) omalloc (pn * sizeof (sorted_pair_node **));
2151 for(j = 0; j < pn; j++)
2152 {
2153 p_Test (p[j], c->r);
2154 sbuf[j] = add_to_basis_ideal_quotient (p[j], c, ibuf + j);
2155 }
2156 int sum = 0;
2157 for(j = 0; j < pn; j++)
2158 {
2159 sum += ibuf[j];
2160 }
2161 sorted_pair_node **big_sbuf =
2162 (sorted_pair_node **) omalloc (sum * sizeof (sorted_pair_node *));
2163 int partsum = 0;
2164 for(j = 0; j < pn; j++)
2165 {
2166 memmove (big_sbuf + partsum, sbuf[j],
2167 ibuf[j] * sizeof (sorted_pair_node *));
2168 omFree (sbuf[j]);
2169 partsum += ibuf[j];
2170 }
2171
2172 qsort (big_sbuf, sum, sizeof (sorted_pair_node *), tgb_pair_better_gen2);
2173 c->apairs = spn_merge (c->apairs, c->pair_top + 1, big_sbuf, sum, c);
2174 c->pair_top += sum;
2176 omFree (big_sbuf);
2177 omFree (sbuf);
2178 omFree (ibuf);
2179 //omfree(buf);
2180#ifdef TGB_DEBUG
2181 int z;
2182 for(z = 1; z <= c->pair_top; z++)
2183 {
2184 assume (pair_better (c->apairs[z], c->apairs[z - 1], c));
2185 }
2186#endif
2187
2188}
sorted_pair_node ** add_to_basis_ideal_quotient(poly h, slimgb_alg *c, int *ip)
Definition: tgb.cc:1426
static BOOLEAN pair_better(sorted_pair_node *a, sorted_pair_node *b, slimgb_alg *c=NULL)
Definition: tgb.cc:4006

◆ monomial_root()

static BOOLEAN monomial_root ( poly  m,
ring  r 
)
static

Definition at line 89 of file tgb.cc.

90{
91 BOOLEAN changed = FALSE;
92 int i;
93 for(i = 1; i <= rVar (r); i++)
94 {
95 int e = p_GetExp (m, i, r);
96 if(e > 1)
97 {
98 p_SetExp (m, i, 1, r);
99 changed = TRUE;
100 }
101 }
102 if(changed)
103 {
104 p_Setm (m, r);
105 }
106 return changed;
107}
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
Definition: p_polys.h:488
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:594

◆ move_backward_in_S()

static void move_backward_in_S ( int  old_pos,
int  new_pos,
kStrategy  strat 
)
static

Definition at line 1064 of file tgb.cc.

1065{
1066 assume (old_pos <= new_pos);
1067 poly p = strat->S[old_pos];
1068 int ecart = strat->ecartS[old_pos];
1069 long sev = strat->sevS[old_pos];
1070 int s_2_r = strat->S_2_R[old_pos];
1071 int length = strat->lenS[old_pos];
1072 assume (length == pLength (strat->S[old_pos]));
1073 wlen_type length_w;
1074 if(strat->lenSw != NULL)
1075 length_w = strat->lenSw[old_pos];
1076 int i;
1077 for(i = old_pos; i < new_pos; i++)
1078 {
1079 strat->S[i] = strat->S[i + 1];
1080 strat->ecartS[i] = strat->ecartS[i + 1];
1081 strat->sevS[i] = strat->sevS[i + 1];
1082 strat->S_2_R[i] = strat->S_2_R[i + 1];
1083 }
1084 if(strat->lenS != NULL)
1085 for(i = old_pos; i < new_pos; i++)
1086 strat->lenS[i] = strat->lenS[i + 1];
1087 if(strat->lenSw != NULL)
1088 for(i = old_pos; i < new_pos; i++)
1089 strat->lenSw[i] = strat->lenSw[i + 1];
1090
1091 strat->S[new_pos] = p;
1092 strat->ecartS[new_pos] = ecart;
1093 strat->sevS[new_pos] = sev;
1094 strat->S_2_R[new_pos] = s_2_r;
1095 strat->lenS[new_pos] = length;
1096 if(strat->lenSw != NULL)
1097 strat->lenSw[new_pos] = length_w;
1098 //assume(lenS_correct(strat));
1099}
int * S_2_R
Definition: kutil.h:345
intset ecartS
Definition: kutil.h:310
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257

◆ move_forward_in_S()

static void move_forward_in_S ( int  old_pos,
int  new_pos,
kStrategy  strat 
)
static

Definition at line 1027 of file tgb.cc.

1028{
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];
1034 int length = strat->lenS[old_pos];
1035 assume (length == pLength (strat->S[old_pos]));
1036 wlen_type length_w;
1037 if(strat->lenSw != NULL)
1038 length_w = strat->lenSw[old_pos];
1039 int i;
1040 for(i = old_pos; i > new_pos; i--)
1041 {
1042 strat->S[i] = strat->S[i - 1];
1043 strat->ecartS[i] = strat->ecartS[i - 1];
1044 strat->sevS[i] = strat->sevS[i - 1];
1045 strat->S_2_R[i] = strat->S_2_R[i - 1];
1046 }
1047 if(strat->lenS != NULL)
1048 for(i = old_pos; i > new_pos; i--)
1049 strat->lenS[i] = strat->lenS[i - 1];
1050 if(strat->lenSw != NULL)
1051 for(i = old_pos; i > new_pos; i--)
1052 strat->lenSw[i] = strat->lenSw[i - 1];
1053
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;
1058 strat->lenS[new_pos] = length;
1059 if(strat->lenSw != NULL)
1060 strat->lenSw[new_pos] = length_w;
1061 //assume(lenS_correct(strat));
1062}

◆ multi_reduce_step()

void multi_reduce_step ( find_erg erg,
red_object r,
slimgb_alg c 
)
static

Definition at line 4978 of file tgb.cc.

4979{
4980 STATIC_VAR int id = 0;
4981 id++;
4982 unsigned long sev;
4983 BOOLEAN lt_changed = FALSE;
4984 int rn = erg.reduce_by;
4985 poly red;
4986 int red_len;
4987 simple_reducer *pointer;
4988 BOOLEAN work_on_copy = FALSE;
4989 if(erg.fromS)
4990 {
4991 red = c->strat->S[rn];
4992 red_len = c->strat->lenS[rn];
4993 assume (red_len == pLength (red));
4994 }
4995 else
4996 {
4997 r[rn].flatten ();
4998 kBucketClear (r[rn].bucket, &red, &red_len);
4999
5001 {
5002 p_Cleardenom (red, c->r); //should be unnecessary
5003 //includes p_Content(red, c->r);
5004 }
5005 //pNormalize (red);
5006
5007 if((!(erg.fromS)) && (TEST_V_UPTORADICAL))
5008 {
5009 if(polynomial_root (red, c->r))
5010 lt_changed = TRUE;
5011 sev = p_GetShortExpVector (red, c->r);
5012 }
5013 red_len = pLength (red);
5014 }
5015 if(((TEST_V_MODPSOLVSB) && (red_len > 1))
5016 || ((c->nc) || (erg.to_reduce_u - erg.to_reduce_l > 5)))
5017 {
5018 work_on_copy = TRUE;
5019 // poly m=pOne();
5020 poly m = c->tmp_lm;
5021 pSetCoeff (m, nInit (1));
5022 pSetComp (m, 0);
5023 for(int i = 1; i <= (currRing->N); i++)
5024 pSetExp (m, i, (pGetExp (r[erg.to_reduce_l].p, i) - pGetExp (red, i)));
5025 pSetm (m);
5026 poly red_cp;
5027#ifdef HAVE_PLURAL
5028 if(c->nc)
5029 red_cp = nc_mm_Mult_pp (m, red, c->r);
5030 else
5031#endif
5032 red_cp = ppMult_mm (red, m);
5033 if(!erg.fromS)
5034 {
5035 kBucketInit (r[rn].bucket, red, red_len);
5036 }
5037 //now reduce the copy
5038 //static poly redNF2 (poly h,slimgb_alg* c , int &len, number& m,int n)
5039
5040 if(!c->nc)
5041 redTailShort (red_cp, c->strat);
5042 //number mul;
5043 // red_len--;
5044// red_cp->next=redNF2(red_cp->next,c,red_len,mul,c->average_length);
5045// pSetCoeff(red_cp,nMult(red_cp->coef,mul));
5046// nDelete(&mul);
5047// red_len++;
5048 red = red_cp;
5049 red_len = pLength (red);
5050 // pDelete(&m);
5051 }
5052
5053 assume (red_len == pLength (red));
5054
5055 int reducer_deg = 0;
5056 if(c->eliminationProblem)
5057 {
5058 int lm_deg = c->pTotaldegree (r[erg.to_reduce_l].p);
5059 int ecart;
5060 if(erg.fromS)
5061 {
5062 ecart = c->strat->ecartS[erg.reduce_by];
5063 }
5064 else
5065 {
5066 ecart = c->pTotaldegree_full (red) - lm_deg;
5067 }
5068 reducer_deg = lm_deg + ecart;
5069 }
5070 pointer = new simple_reducer (red, red_len, reducer_deg, c);
5071
5072 if((!work_on_copy) && (!erg.fromS))
5073 pointer->fill_back = r[rn].bucket;
5074 else
5075 pointer->fill_back = NULL;
5076 pointer->reduction_id = id;
5077 pointer->c = c;
5078
5079 pointer->reduce (r, erg.to_reduce_l, erg.to_reduce_u);
5080 if(work_on_copy)
5081 pDelete (&pointer->p);
5082 delete pointer;
5083 if(lt_changed)
5084 {
5085 assume (!erg.fromS);
5086 r[erg.reduce_by].sev = sev;
5087 }
5088}
void flatten()
Definition: tgb.cc:4905
kBucket_pt bucket
Definition: tgb_internal.h:298
slimgb_alg * c
Definition: tgb_internal.h:343
kBucket_pt fill_back
Definition: tgb_internal.h:350
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,...
Definition: tgb.cc:4941
BOOLEAN eliminationProblem
Definition: tgb_internal.h:269
#define STATIC_VAR
Definition: globaldefs.h:7
static poly nc_mm_Mult_pp(const poly m, const poly p, const ring r)
Definition: nc.h:224
#define nInit(i)
Definition: numbers.h:24
#define TEST_V_MODPSOLVSB
Definition: options.h:139
#define ppMult_mm(p, m)
Definition: polys.h:201
#define pSetComp(p, v)
Definition: polys.h:38
static BOOLEAN polynomial_root(poly h, ring r)
Definition: tgb.cc:109
BOOLEAN fromS
Definition: tgb_internal.h:379
int to_reduce_u
Definition: tgb_internal.h:376
int to_reduce_l
Definition: tgb_internal.h:377
int reduce_by
Definition: tgb_internal.h:378

◆ multi_reduction()

static void multi_reduction ( red_object los,
int &  losl,
slimgb_alg c 
)
static

Definition at line 4722 of file tgb.cc.

4723{
4724 poly *delay = (poly *) omAlloc (losl * sizeof (poly));
4725 int delay_s = 0;
4726 //initialize;
4727 assume (c->strat->sl >= 0);
4728 assume (losl > 0);
4729 int i;
4730 wlen_type max_initial_quality = 0;
4731
4732 for(i = 0; i < losl; i++)
4733 {
4734 los[i].sev = pGetShortExpVector (los[i].p);
4735//SetShortExpVector();
4736 los[i].p = kBucketGetLm (los[i].bucket);
4737 if(los[i].initial_quality > max_initial_quality)
4738 max_initial_quality = los[i].initial_quality;
4739 // else
4740// Print("init2_qal=%lld;", los[i].initial_quality);
4741// Print("initial_quality=%lld;",max_initial_quality);
4742 }
4743
4744 int curr_pos = losl - 1;
4745
4746// nicht reduzierbare eintrage in ergnisliste schreiben
4747 // nullen loeschen
4748 while(curr_pos >= 0)
4749 {
4750 if((c->use_noro_last_block)
4751 && (lies_in_last_dp_block (los[curr_pos].p, c)))
4752 {
4753 int pn_noro = curr_pos + 1;
4754 poly *p_noro = (poly *) omAlloc (pn_noro * sizeof (poly));
4755 for(i = 0; i < pn_noro; i++)
4756 {
4757 int dummy_len;
4758 poly p;
4759 los[i].p = NULL;
4760 kBucketClear (los[i].bucket, &p, &dummy_len);
4761 p_noro[i] = p;
4762 }
4763 if(n_GetChar(currRing->cf) < 255)
4764 {
4765 noro_step < tgb_uint8 > (p_noro, pn_noro, c);
4766 }
4767 else
4768 {
4769 if(n_GetChar(currRing->cf) < 65000)
4770 {
4771 noro_step < tgb_uint16 > (p_noro, pn_noro, c);
4772 }
4773 else
4774 {
4775 noro_step < tgb_uint32 > (p_noro, pn_noro, c);
4776 }
4777 }
4778 for(i = 0; i < pn_noro; i++)
4779 {
4780 los[i].p = p_noro[i];
4781 los[i].sev = pGetShortExpVector (los[i].p);
4782 //ignore quality
4783 kBucketInit (los[i].bucket, los[i].p, pLength (los[i].p));
4784 }
4785 qsort (los, pn_noro, sizeof (red_object), red_object_better_gen);
4786 int deleted =
4787 multi_reduction_clear_zeroes (los, losl, pn_noro, curr_pos);
4788 losl -= deleted;
4789 curr_pos -= deleted;
4790 break;
4791 }
4792 find_erg erg;
4793
4794 multi_reduction_find (los, losl, c, curr_pos, erg); //last argument should be curr_pos
4795 if(erg.reduce_by < 0)
4796 break;
4797
4798 erg.expand = NULL;
4799
4800 multi_reduction_lls_trick (los, losl, c, erg);
4801
4802 int i;
4803 // wrp(los[erg.to_reduce_u].p);
4804 //PrintLn();
4805 multi_reduce_step (erg, los, c);
4806
4807
4809 {
4810 for(i = erg.to_reduce_l; i <= erg.to_reduce_u; i++)
4811 {
4812 if(los[i].p != NULL) //the check (los[i].p!=NULL) might be invalid
4813 {
4814 //
4815 assume (los[i].initial_quality > 0);
4816 if(los[i].guess_quality (c)
4817 > 1.5 * delay_factor * max_initial_quality)
4818 {
4819 if(TEST_OPT_PROT)
4820 PrintS ("v");
4821 los[i].canonicalize ();
4822 if(los[i].guess_quality (c) > delay_factor * max_initial_quality)
4823 {
4824 if(TEST_OPT_PROT)
4825 PrintS (".");
4826 los[i].clear_to_poly ();
4827 //delay.push_back(los[i].p);
4828 delay[delay_s] = los[i].p;
4829 delay_s++;
4830 los[i].p = NULL;
4831 }
4832 }
4833 }
4834 }
4835 }
4836 int deleted = multi_reduction_clear_zeroes (los, losl, erg.to_reduce_l,
4837 erg.to_reduce_u);
4838 if(erg.fromS == FALSE)
4839 curr_pos = si_max (erg.to_reduce_u, erg.reduce_by);
4840 else
4841 curr_pos = erg.to_reduce_u;
4842 losl -= deleted;
4843 curr_pos -= deleted;
4844
4845 //Print("deleted %i \n",deleted);
4846 if((TEST_V_UPTORADICAL) && (!(erg.fromS)))
4848 (si_max (erg.to_reduce_u, erg.reduce_by)) - deleted,
4849 c);
4850 else
4851 sort_region_down (los, erg.to_reduce_l, erg.to_reduce_u - deleted, c);
4852
4853 if(erg.expand)
4854 {
4855#ifdef FIND_DETERMINISTIC
4856 int i;
4857 for(i = 0; c->expandS[i]; i++) ;
4858 c->expandS = (poly *) omrealloc (c->expandS, (i + 2) * sizeof (poly));
4859 c->expandS[i] = erg.expand;
4860 c->expandS[i + 1] = NULL;
4861#else
4862 int ecart = 0;
4863 if(c->eliminationProblem)
4864 {
4865 ecart =
4866 c->pTotaldegree_full (erg.expand) - c->pTotaldegree (erg.expand);
4867 }
4868 add_to_reductors (c, erg.expand, erg.expand_length, ecart);
4869#endif
4870 }
4871 }
4872
4873 //sorted_pair_node** pairs=(sorted_pair_node**)
4874 // omalloc(delay_s*sizeof(sorted_pair_node*));
4875 c->introduceDelayedPairs (delay, delay_s);
4876 /*
4877 for(i=0;i<delay_s;i++)
4878 {
4879 poly p=delay[i];
4880 //if (rPar(c->r)==0)
4881 simplify_poly(p,c->r);
4882 sorted_pair_node* si=(sorted_pair_node*) omalloc(sizeof(sorted_pair_node));
4883 si->i=-1;
4884 si->j=-1;
4885 if (!rField_is_Zp(c->r))
4886 {
4887 if (!c->nc)
4888 p=redTailShort(p, c->strat);
4889 p_Cleardenom(p, c->r);
4890 p_Content(p, c->r);
4891 }
4892 si->expected_length=pQuality(p,c,pLength(p));
4893 si->deg=pTotaldegree(p);
4894 si->lcm_of_lm=p;
4895 pairs[i]=si;
4896 }
4897 qsort(pairs,delay_s,sizeof(sorted_pair_node*),tgb_pair_better_gen2);
4898 c->apairs=spn_merge(c->apairs,c->pair_top+1,pairs,delay_s,c);
4899 c->pair_top+=delay_s; */
4900 omFree (delay);
4901 //omfree(pairs);
4902 return;
4903}
wlen_type initial_quality
Definition: tgb_internal.h:303
int clear_to_poly()
Definition: tgb.cc:4917
void canonicalize()
Definition: tgb.cc:871
poly * expandS
Definition: tgb_internal.h:227
#define omrealloc(addr, size)
Definition: omAllocDecl.h:233
#define TEST_OPT_REDTHROUGH
Definition: options.h:122
static void sort_region_down(red_object *los, int l, int u, slimgb_alg *)
Definition: tgb.cc:4666
static int multi_reduction_clear_zeroes(red_object *los, int losl, int l, int u)
Definition: tgb.cc:4613
static const int delay_factor
Definition: tgb.cc:38
static void multi_reduction_find(red_object *los, int, slimgb_alg *c, int startf, find_erg &erg)
Definition: tgb.cc:4539
static void multi_reduce_step(find_erg &erg, red_object *r, slimgb_alg *c)
Definition: tgb.cc:4978
static void multi_reduction_lls_trick(red_object *los, int, slimgb_alg *c, find_erg &erg)
Definition: tgb.cc:4209
poly expand
Definition: tgb_internal.h:374
int expand_length
Definition: tgb_internal.h:375

◆ multi_reduction_clear_zeroes()

static int multi_reduction_clear_zeroes ( red_object los,
int  losl,
int  l,
int  u 
)
static

Definition at line 4613 of file tgb.cc.

4614{
4615 int deleted = 0;
4616 int i = l;
4617 int last = -1;
4618 while(i <= u)
4619 {
4620 if(los[i].p == NULL)
4621 {
4622 kBucketDestroy (&los[i].bucket);
4623// delete los[i];//here we assume los are constructed with new
4624 //destroy resources, must be added here
4625 if(last >= 0)
4626 {
4627 memmove (los + (int) (last + 1 - deleted), los + (last + 1),
4628 sizeof (red_object) * (i - 1 - last));
4629 }
4630 last = i;
4631 deleted++;
4632 }
4633 i++;
4634 }
4635 if((last >= 0) && (last != losl - 1))
4636 memmove (los + (int) (last + 1 - deleted), los + last + 1,
4637 sizeof (red_object) * (losl - 1 - last));
4638 return deleted;
4639}
STATIC_VAR poly last
Definition: hdegree.cc:1150

◆ multi_reduction_find()

static void multi_reduction_find ( red_object los,
int  ,
slimgb_alg c,
int  startf,
find_erg erg 
)
static

Definition at line 4539 of file tgb.cc.

4546{
4547 kStrategy strat = c->strat;
4548
4549 #ifndef SING_NDEBUG
4550 assume (startf <= losl);
4551 assume ((startf == losl - 1)
4552 || (pLmCmp (los[startf].p, los[startf + 1].p) == -1));
4553 #endif
4554 int i = startf;
4555
4556 int j;
4557 while(i >= 0)
4558 {
4559 #ifndef SING_NDEBUG
4560 assume ((i == losl - 1) || (pLmCmp (los[i].p, los[i + 1].p) <= 0));
4561 #endif
4562 assume (is_valid_ro (los[i]));
4563 j = kFindDivisibleByInS_easy (strat, los[i]);
4564 if(j >= 0)
4565 {
4566 erg.to_reduce_u = i;
4567 erg.reduce_by = j;
4568 erg.fromS = TRUE;
4569 int i2 = fwbw (los, i);
4570 assume (pLmEqual (los[i].p, los[i2].p));
4571 assume ((i2 == 0) || (!pLmEqual (los[i2].p, los[i2 - 1].p)));
4572 assume (i >= i2);
4573
4574 erg.to_reduce_l = i2;
4575 #ifndef SING_NDEBUG
4576 assume ((i == losl - 1) || (pLmCmp (los[i].p, los[i + 1].p) == -1));
4577 #endif
4578 canonicalize_region (los, erg.to_reduce_u + 1, startf, c);
4579 return;
4580 }
4581 else /*if(j < 0)*/
4582 {
4583 //not reduceable, try to use this for reducing higher terms
4584 int i2 = fwbw (los, i);
4585 assume (pLmEqual (los[i].p, los[i2].p));
4586 assume ((i2 == 0) || (!pLmEqual (los[i2].p, los[i2 - 1].p)));
4587 assume (i >= i2);
4588 if(i2 != i)
4589 {
4590 erg.to_reduce_u = i - 1;
4591 erg.to_reduce_l = i2;
4592 erg.reduce_by = i;
4593 erg.fromS = FALSE;
4594 #ifndef SING_NDEBUG
4595 assume ((i == losl - 1) || (pLmCmp (los[i].p, los[i + 1].p) == -1));
4596 #endif
4597 canonicalize_region (los, erg.to_reduce_u + 1, startf, c);
4598 return;
4599 }
4600 i--;
4601 }
4602 }
4603 erg.reduce_by = -1; //error code
4604 return;
4605}
static int fwbw(red_object *los, int i)
Definition: tgb.cc:4469
BOOLEAN is_valid_ro(red_object &ro)
Definition: tgb.cc:2021
static void canonicalize_region(red_object *los, int l, int u, slimgb_alg *)
Definition: tgb.cc:4527

◆ multi_reduction_lls_trick()

static void multi_reduction_lls_trick ( red_object los,
int  ,
slimgb_alg c,
find_erg erg 
)
static

Definition at line 4209 of file tgb.cc.

4211{
4212 erg.expand = NULL;
4213 BOOLEAN swap_roles; //from reduce_by, to_reduce_u if fromS
4214 if(erg.fromS)
4215 {
4216 if(pLmEqual (c->strat->S[erg.reduce_by], los[erg.to_reduce_u].p))
4217 {
4218 wlen_type quality_a = quality_of_pos_in_strat_S (erg.reduce_by, c);
4219 int best = erg.to_reduce_u + 1;
4220/*
4221 for (i=erg.to_reduce_u;i>=erg.to_reduce_l;i--)
4222 {
4223 int qc=los[i].guess_quality(c);
4224 if (qc<quality_a)
4225 {
4226 best=i;
4227 quality_a=qc;
4228 }
4229 }
4230 if(best!=erg.to_reduce_u+1)
4231 {*/
4232 wlen_type qc;
4233 best = find_best (los, erg.to_reduce_l, erg.to_reduce_u, qc, c);
4234 if(qc < quality_a)
4235 {
4236 los[best].flatten ();
4237 int b_pos = kBucketCanonicalize (los[best].bucket);
4238 los[best].p = los[best].bucket->buckets[b_pos];
4239 qc = pQuality (los[best].bucket->buckets[b_pos], c);
4240 if(qc < quality_a)
4241 {
4242 red_object h = los[erg.to_reduce_u];
4243 los[erg.to_reduce_u] = los[best];
4244 los[best] = h;
4245 swap_roles = TRUE;
4246 }
4247 else
4248 swap_roles = FALSE;
4249 }
4250 else
4251 {
4252 swap_roles = FALSE;
4253 }
4254 }
4255 else
4256 {
4257 if(erg.to_reduce_u > erg.to_reduce_l)
4258 {
4259 wlen_type quality_a = quality_of_pos_in_strat_S (erg.reduce_by, c);
4260#ifdef HAVE_PLURAL
4261 if((c->nc) && (!(rIsSCA (c->r))))
4262 quality_a =
4264 los[erg.to_reduce_u].p, c);
4265#endif
4266 int best = erg.to_reduce_u + 1;
4267 wlen_type qc;
4268 best = find_best (los, erg.to_reduce_l, erg.to_reduce_u, qc, c);
4269 assume (qc == los[best].guess_quality (c));
4270 if(qc < quality_a)
4271 {
4272 los[best].flatten ();
4273 int b_pos = kBucketCanonicalize (los[best].bucket);
4274 los[best].p = los[best].bucket->buckets[b_pos];
4275 qc = pQuality (los[best].bucket->buckets[b_pos], c);
4276 //(best!=erg.to_reduce_u+1)
4277 if(qc < quality_a)
4278 {
4279 red_object h = los[erg.to_reduce_u];
4280 los[erg.to_reduce_u] = los[best];
4281 los[best] = h;
4282 erg.reduce_by = erg.to_reduce_u;
4283 erg.fromS = FALSE;
4284 erg.to_reduce_u--;
4285 }
4286 }
4287 }
4288 else
4289 {
4290 assume (erg.to_reduce_u == erg.to_reduce_l);
4291 wlen_type quality_a = quality_of_pos_in_strat_S (erg.reduce_by, c);
4292 wlen_type qc = los[erg.to_reduce_u].guess_quality (c);
4293 if(qc < 0)
4294 PrintS ("Wrong wlen_type");
4295 if(qc < quality_a)
4296 {
4297 int best = erg.to_reduce_u;
4298 los[best].flatten ();
4299 int b_pos = kBucketCanonicalize (los[best].bucket);
4300 los[best].p = los[best].bucket->buckets[b_pos];
4301 qc = pQuality (los[best].bucket->buckets[b_pos], c);
4302 assume (qc >= 0);
4303 if(qc < quality_a)
4304 {
4305 BOOLEAN exp = FALSE;
4306 if(qc <= 2)
4307 {
4308 //Print("\n qc is %lld \n",qc);
4309 exp = TRUE;
4310 }
4311 else
4312 {
4313 if(qc < quality_a / 2)
4314 exp = TRUE;
4315 else if(erg.reduce_by < c->n / 4)
4316 exp = TRUE;
4317 }
4318 if(exp)
4319 {
4320 poly clear_into;
4321 los[erg.to_reduce_u].flatten ();
4322 kBucketClear (los[erg.to_reduce_u].bucket, &clear_into,
4323 &erg.expand_length);
4324 erg.expand = pCopy (clear_into);
4325 kBucketInit (los[erg.to_reduce_u].bucket, clear_into,
4326 erg.expand_length);
4327 if(TEST_OPT_PROT)
4328 PrintS ("e");
4329 }
4330 }
4331 }
4332 }
4333
4334 swap_roles = FALSE;
4335 return;
4336 }
4337 }
4338 else
4339 {
4340 if(erg.reduce_by > erg.to_reduce_u)
4341 {
4342 //then lm(rb)>= lm(tru) so =
4343 assume (erg.reduce_by == erg.to_reduce_u + 1);
4344 int best = erg.reduce_by;
4345 wlen_type quality_a = los[erg.reduce_by].guess_quality (c);
4346 wlen_type qc;
4347 best = find_best (los, erg.to_reduce_l, erg.to_reduce_u, qc, c);
4348
4349 if(qc < quality_a)
4350 {
4351 red_object h = los[erg.reduce_by];
4352 los[erg.reduce_by] = los[best];
4353 los[best] = h;
4354 }
4355 swap_roles = FALSE;
4356 return;
4357 }
4358 else
4359 {
4360 assume (!pLmEqual (los[erg.reduce_by].p, los[erg.to_reduce_l].p));
4361 assume (erg.to_reduce_u == erg.to_reduce_l);
4362 //further assume, that reduce_by is the above all other polys
4363 //with same leading term
4364 int il = erg.reduce_by;
4365 wlen_type quality_a = los[erg.reduce_by].guess_quality (c);
4366 wlen_type qc;
4367 while((il > 0) && pLmEqual (los[il - 1].p, los[il].p))
4368 {
4369 il--;
4370 qc = los[il].guess_quality (c);
4371 if(qc < quality_a)
4372 {
4373 quality_a = qc;
4374 erg.reduce_by = il;
4375 }
4376 }
4377 swap_roles = FALSE;
4378 }
4379 }
4380 if(swap_roles)
4381 {
4382 if(TEST_OPT_PROT)
4383 PrintS ("b");
4384 poly clear_into;
4385 int new_length;
4386 int bp = erg.to_reduce_u; //bucket_positon
4387 //kBucketClear(los[bp].bucket,&clear_into,&new_length);
4388 new_length = los[bp].clear_to_poly ();
4389 clear_into = los[bp].p;
4390 poly p = c->strat->S[erg.reduce_by];
4391 int j = erg.reduce_by;
4392 int old_length = c->strat->lenS[j]; // in view of S
4393 los[bp].p = p;
4394 kBucketInit (los[bp].bucket, p, old_length);
4395 wlen_type qal = pQuality (clear_into, c, new_length);
4396 int pos_in_c = -1;
4397 int z;
4398 int new_pos;
4399 new_pos = simple_posInS (c->strat, clear_into, new_length, qal);
4400 assume (new_pos <= j);
4401 for(z = c->n; z; z--)
4402 {
4403 if(p == c->S->m[z - 1])
4404 {
4405 pos_in_c = z - 1;
4406 break;
4407 }
4408 }
4409
4410 int tdeg_full = -1;
4411 int tdeg = -1;
4412 if(pos_in_c >= 0)
4413 {
4414#ifdef TGB_RESORT_PAIRS
4415 c->used_b = TRUE;
4416 c->replaced[pos_in_c] = TRUE;
4417#endif
4418 tdeg = c->T_deg[pos_in_c];
4419 c->S->m[pos_in_c] = clear_into;
4420 c->lengths[pos_in_c] = new_length;
4421 c->weighted_lengths[pos_in_c] = qal;
4422 if(c->gcd_of_terms[pos_in_c] == NULL)
4423 c->gcd_of_terms[pos_in_c] = gcd_of_terms (clear_into, c->r);
4424 if(c->T_deg_full)
4425 tdeg_full = c->T_deg_full[pos_in_c] =
4426 c->pTotaldegree_full (clear_into);
4427 else
4428 tdeg_full = tdeg;
4429 c_S_element_changed_hook (pos_in_c, c);
4430 }
4431 else
4432 {
4433 if(c->eliminationProblem)
4434 {
4435 tdeg_full = c->pTotaldegree_full (clear_into);
4436 tdeg = c->pTotaldegree (clear_into);
4437 }
4438 }
4439 c->strat->S[j] = clear_into;
4440 c->strat->lenS[j] = new_length;
4441
4442 assume (pLength (clear_into) == new_length);
4443 if(c->strat->lenSw != NULL)
4444 c->strat->lenSw[j] = qal;
4446 {
4447 p_Cleardenom (clear_into, c->r); //should be unnecessary
4448 //includes p_Content(clear_into, c->r);
4449 }
4450 else
4451 pNorm (clear_into);
4452#ifdef FIND_DETERMINISTIC
4453 erg.reduce_by = j;
4454 //resort later see diploma thesis, find_in_S must be deterministic
4455 //during multireduction if spolys are only in the span of the
4456 //input polys
4457#else
4458 if(new_pos < j)
4459 {
4460 if(c->strat->honey)
4461 c->strat->ecartS[j] = tdeg_full - tdeg;
4462 move_forward_in_S (j, new_pos, c->strat);
4463 erg.reduce_by = new_pos;
4464 }
4465#endif
4466 }
4467}
char honey
Definition: kutil.h:381
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357
static void move_forward_in_S(int old_pos, int new_pos, kStrategy strat)
Definition: tgb.cc:1027
int find_best(red_object *r, int l, int u, wlen_type &w, slimgb_alg *c)
returns position sets w as weight
Definition: tgb.cc:854
static wlen_type quality_of_pos_in_strat_S(int pos, slimgb_alg *c)
Definition: tgb.cc:4186
static void c_S_element_changed_hook(int pos, slimgb_alg *c)
Definition: tgb.cc:1971
static wlen_type quality_of_pos_in_strat_S_mult_high(int pos, poly high, slimgb_alg *c)
Definition: tgb.cc:4195
int tdeg(poly p)
Definition: walkSupport.cc:35

◆ now_t_rep()

void now_t_rep ( const int &  arg_i,
const int &  arg_j,
slimgb_alg c 
)

Definition at line 3705 of file tgb.cc.

3706{
3707 int i, j;
3708 if(arg_i == arg_j)
3709 {
3710 return;
3711 }
3712 if(arg_i > arg_j)
3713 {
3714 i = arg_j;
3715 j = arg_i;
3716 }
3717 else
3718 {
3719 i = arg_i;
3720 j = arg_j;
3721 }
3722 c->states[j][i] = HASTREP;
3723}

◆ p_Init_Special()

static poly p_Init_Special ( const ring  r)
inlinestatic

Definition at line 137 of file tgb.cc.

138{
139 return p_Init (r, lm_bin);
140}
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1280
STATIC_VAR omBin lm_bin
Definition: tgb.cc:41

◆ pair_better()

static BOOLEAN pair_better ( sorted_pair_node a,
sorted_pair_node b,
slimgb_alg c = NULL 
)
static

Definition at line 4006 of file tgb.cc.

4007{
4008 if(a->deg < b->deg)
4009 return TRUE;
4010 if(a->deg > b->deg)
4011 return FALSE;
4012
4013 int comp = pLmCmp (a->lcm_of_lm, b->lcm_of_lm);
4014 if(comp == 1)
4015 return FALSE;
4016 if(-1 == comp)
4017 return TRUE;
4018 if(a->expected_length < b->expected_length)
4019 return TRUE;
4020 if(a->expected_length > b->expected_length)
4021 return FALSE;
4022 if(a->i + a->j < b->i + b->j)
4023 return TRUE;
4024 if(a->i + a->j > b->i + b->j)
4025 return FALSE;
4026 if(a->i < b->i)
4027 return TRUE;
4028 if(a->i > b->i)
4029 return FALSE;
4030 return TRUE;
4031}

◆ pair_weighted_length()

static wlen_type pair_weighted_length ( int  i,
int  j,
slimgb_alg c 
)
static

Definition at line 1373 of file tgb.cc.

1374{
1375 if((c->isDifficultField) && (c->eliminationProblem))
1376 {
1377 int c1 = slim_nsize (p_GetCoeff (c->S->m[i], c->r), c->r);
1378 int c2 = slim_nsize (p_GetCoeff (c->S->m[j], c->r), c->r);
1379 wlen_type el1 = c->weighted_lengths[i] / c1;
1380 assume (el1 != 0);
1381 assume (c->weighted_lengths[i] % c1 == 0);
1382 wlen_type el2 = c->weighted_lengths[j] / c2;
1383 assume (el2 != 0);
1384 //assume (c->weighted_lengths[j] % c2 == 0); // fails in Tst/Plural/dmod_lib.tst
1385 //should be * for function fields
1386 //return (c1+c2) * (el1+el2-2);
1387 wlen_type res = coeff_mult_size_estimate (c1, c2, c->r);
1388 res *= el1 + el2 - 2;
1389 return res;
1390
1391 }
1392 if(c->isDifficultField)
1393 {
1394 //int cs=slim_nsize(p_GetCoeff(c->S->m[i],c->r),c->r)+
1395 // slim_nsize(p_GetCoeff(c->S->m[j],c->r),c->r);
1396 if(!(TEST_V_COEFSTRAT))
1397 {
1398 wlen_type cs =
1400 (p_GetCoeff (c->S->m[i], c->r), c->r),
1401 slim_nsize (p_GetCoeff (c->S->m[j], c->r),
1402 c->r), c->r);
1403 return (wlen_type) (c->lengths[i] + c->lengths[j] - 2) * (wlen_type) cs;
1404 }
1405 else
1406 {
1407
1408 wlen_type cs =
1410 (p_GetCoeff (c->S->m[i], c->r), c->r),
1411 slim_nsize (p_GetCoeff (c->S->m[j], c->r),
1412 c->r), c->r);
1413 cs *= cs;
1414 return (wlen_type) (c->lengths[i] + c->lengths[j] - 2) * (wlen_type) cs;
1415 }
1416 }
1417 if(c->eliminationProblem)
1418 {
1419
1420 return (c->weighted_lengths[i] + c->weighted_lengths[j] - 2);
1421 }
1422 return c->lengths[i] + c->lengths[j] - 2;
1423
1424}
BOOLEAN isDifficultField
Definition: tgb_internal.h:265
#define p_GetCoeff(p, r)
Definition: monomials.h:50
static wlen_type coeff_mult_size_estimate(int s1, int s2, ring r)
Definition: tgb.cc:1365
int slim_nsize(number n, ring r)
Definition: tgb.cc:73

◆ pELength() [1/2]

static int pELength ( poly  p,
slimgb_alg c,
int  l 
)
inlinestatic

Definition at line 535 of file tgb.cc.

536{
537 if(p == NULL)
538 return 0;
539 if((l > 0) && (elength_is_normal_length (p, c)))
540 return l;
541 return do_pELength (p, c);
542}

◆ pELength() [2/2]

wlen_type pELength ( poly  p,
slimgb_alg c,
ring   
)

Definition at line 471 of file tgb.cc.

472{
473 if(p == NULL)
474 return 0;
475 wlen_type s = 0;
476 poly pi = p;
477 int dlm;
478 dlm = c->pTotaldegree (p);
479 s = 1;
480 pi = p->next;
481
482 while(pi)
483 {
484 int d = c->pTotaldegree (pi);
485 if(d > dlm)
486 s += 1 + d - dlm;
487 else
488 ++s;
489 pi = pi->next;
490 }
491 return s;
492}

◆ pHasNotCFExtended()

static BOOLEAN pHasNotCFExtended ( poly  p1,
poly  p2,
poly  m 
)
inlinestatic

Definition at line 4105 of file tgb.cc.

4106{
4107
4108 if(pGetComp (p1) > 0 || pGetComp (p2) > 0)
4109 return FALSE;
4110 int i = 1;
4111 loop
4112 {
4113 if((pGetExp (p1, i) - pGetExp (m, i) > 0)
4114 && (pGetExp (p2, i) - pGetExp (m, i) > 0))
4115 return FALSE;
4116 if(i == (currRing->N))
4117 return TRUE;
4118 i++;
4119 }
4120}
#define loop
Definition: structs.h:80

◆ poly_crit()

static int poly_crit ( const void *  ap1,
const void *  ap2 
)
static

Definition at line 3166 of file tgb.cc.

3167{
3168 poly p1, p2;
3169 p1 = *((poly *) ap1);
3170 p2 = *((poly *) ap2);
3171
3172 int c = pLmCmp (p1, p2);
3173 if(c != 0)
3174 return c;
3175 int l1 = pLength (p1);
3176 int l2 = pLength (p2);
3177 if(l1 < l2)
3178 return -1;
3179 if(l1 > l2)
3180 return 1;
3181 return 0;
3182}

◆ polynomial_root()

static BOOLEAN polynomial_root ( poly  h,
ring  r 
)
static

Definition at line 109 of file tgb.cc.

110{
111 poly got = gcd_of_terms (h, r);
112 BOOLEAN changed = FALSE;
113 if((got != NULL) && (TEST_V_UPTORADICAL))
114 {
115 poly copy = p_Copy (got, r);
116 //p_wrp(got,c->r);
117 changed = monomial_root (got, r);
118 if(changed)
119 {
120 poly div_by = pMDivide (copy, got);
121 poly iter = h;
122 while(iter)
123 {
124 pExpVectorSub (iter, div_by);
125 pIter (iter);
126 }
127 p_Delete (&div_by, r);
128 if(TEST_OPT_PROT)
129 PrintS ("U");
130 }
131 p_Delete (&copy, r);
132 }
133 p_Delete (&got, r);
134 return changed;
135}

◆ pOne_Special()

static poly pOne_Special ( const ring  r = currRing)
inlinestatic

Definition at line 142 of file tgb.cc.

143{
144 poly rc = p_Init_Special (r);
145 pSetCoeff0 (rc, n_Init (1, r->cf));
146 return rc;
147}
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
#define pSetCoeff0(p, n)
Definition: monomials.h:59
static poly p_Init_Special(const ring r)
Definition: tgb.cc:137

◆ posInPairs()

static int posInPairs ( sorted_pair_node **  p,
int  pn,
sorted_pair_node qe,
slimgb_alg c,
int  an = 0 
)
static

Definition at line 711 of file tgb.cc.

713{
714 if(pn == 0)
715 return 0;
716
717 int length = pn - 1;
718 int i;
719 //int an = 0;
720 int en = length;
721
722 if(pair_better (qe, p[en], c))
723 return length + 1;
724
725 while(1)
726 {
727 //if (an >= en-1)
728 if(en - 1 <= an)
729 {
730 if(pair_better (p[an], qe, c))
731 return an;
732 return en;
733 }
734 i = (an + en) / 2;
735 if(pair_better (p[i], qe, c))
736 en = i;
737 else
738 an = i;
739 }
740}

◆ pQuality()

static wlen_type pQuality ( poly  p,
slimgb_alg c,
int  l = -1 
)
inlinestatic

Definition at line 544 of file tgb.cc.

545{
546 if(l < 0)
547 l = pLength (p);
548 if(c->isDifficultField)
549 {
550 if(c->eliminationProblem)
551 {
552 wlen_type cs;
553 number coef = pGetCoeff (p);
555 {
556 cs = nlQlogSize (coef, currRing->cf);
557 }
558 else
559 cs = nSize (coef);
560 wlen_type erg = cs;
562 erg *= cs;
563 //erg*=cs;//for quadratic
564 erg *= pELength (p, c, l);
565 //FIXME: not quadratic coeff size
566 //return cs*pELength(p,c,l);
567 return erg;
568 }
569 //PrintS("I am here");
570 wlen_type r = pSLength (p, l);
571 assume (r >= 0);
572 return r;
573 }
574 if(c->eliminationProblem)
575 return pELength (p, c, l);
576 return l;
577}
static wlen_type pSLength(poly p, int l)
Definition: tgb.cc:197
wlen_type pELength(poly p, slimgb_alg *c, ring)
Definition: tgb.cc:471

◆ pSLength()

static wlen_type pSLength ( poly  p,
int  l 
)
inlinestatic

Definition at line 197 of file tgb.cc.

198{
199 wlen_type c;
200 number coef = pGetCoeff (p);
202 {
203 c = nlQlogSize (coef, currRing->cf);
204 }
205 else
206 c = nSize (coef);
207 if(!(TEST_V_COEFSTRAT))
208 {
209 return (wlen_type) c *(wlen_type) l /*pLength(p) */ ;
210 }
211 else
212 {
213 wlen_type res = l;
214 res *= c;
215 res *= c;
216 return res;
217 }
218}

◆ pTotaldegree_full()

static int pTotaldegree_full ( poly  p)
inlinestatic

Definition at line 579 of file tgb.cc.

580{
581 int r = 0;
582 while(p)
583 {
584 int d = pTotaldegree (p);
585 r = si_max (r, d);
586 pIter (p);
587 }
588 return r;
589}
static long pTotaldegree(poly p)
Definition: polys.h:282

◆ quality_of_pos_in_strat_S()

static wlen_type quality_of_pos_in_strat_S ( int  pos,
slimgb_alg c 
)
inlinestatic

Definition at line 4186 of file tgb.cc.

4187{
4188 if(c->strat->lenSw != NULL)
4189 return c->strat->lenSw[pos];
4190 return c->strat->lenS[pos];
4191}

◆ quality_of_pos_in_strat_S_mult_high()

static wlen_type quality_of_pos_in_strat_S_mult_high ( int  pos,
poly  high,
slimgb_alg c 
)
inlinestatic

Definition at line 4195 of file tgb.cc.

4197{
4198 poly m = pOne ();
4199 pExpVectorDiff (m, high, c->strat->S[pos]);
4200 poly product = nc_mm_Mult_pp (m, c->strat->S[pos], c->r);
4201 wlen_type erg = pQuality (product, c);
4202 pDelete (&m);
4203 pDelete (&product);
4204 return erg;
4205}
#define pExpVectorDiff(pr, p1, p2)
Definition: polys.h:91

◆ quick_pop_pair()

sorted_pair_node * quick_pop_pair ( slimgb_alg c)

Definition at line 3944 of file tgb.cc.

3945{
3946 if(c->pair_top < 0)
3947 return NULL;
3948 else
3949 return (c->apairs[c->pair_top--]);
3950}

◆ red_object_better_gen()

static int red_object_better_gen ( const void *  ap,
const void *  bp 
)
static

Definition at line 665 of file tgb.cc.

666{
667 return (pLmCmp (((red_object *) ap)->p, ((red_object *) bp)->p));
668}

◆ redNF2()

static poly redNF2 ( poly  h,
slimgb_alg c,
int &  len,
number &  m,
int  n = 0 
)
static

Definition at line 1837 of file tgb.cc.

1838{
1839 m = nInit (1);
1840 if(h == NULL)
1841 return NULL;
1842
1843 assume (len == pLength (h));
1844 kStrategy strat = c->strat;
1845 if(0 > strat->sl)
1846 {
1847 return h;
1848 }
1849 int j;
1850
1851 LObject P (h);
1852 P.SetShortExpVector ();
1853 P.bucket = kBucketCreate (currRing);
1854 // BOOLEAN corr=lenS_correct(strat);
1855 kBucketInit (P.bucket, P.p, len /*pLength(P.p) */ );
1856 //wlen_set lenSw=(wlen_set) c->strat->lenS;
1857 //FIXME: plainly wrong
1858 //strat->lenS;
1859 //if (strat->lenSw!=NULL)
1860 // lenSw=strat->lenSw;
1861 //int max_pos=simple_posInS(strat,P.p);
1862 loop
1863 {
1864 //int dummy=strat->sl;
1865 j = kFindDivisibleByInS_easy (strat, P.p, P.sev);
1866 //j=kFindDivisibleByInS(strat,&dummy,&P);
1867 if((j >= 0) && ((!n) ||
1868 ((strat->lenS[j] <= n) &&
1869 ((strat->lenSw == NULL) || (strat->lenSw[j] <= n)))))
1870 {
1871 nNormalize (pGetCoeff (P.p));
1872#ifdef KDEBUG
1873 if(TEST_OPT_DEBUG)
1874 {
1875 PrintS ("red:");
1876 wrp (h);
1877 PrintS (" with ");
1878 wrp (strat->S[j]);
1879 }
1880#endif
1881
1882 number coef = kBucketPolyRed (P.bucket, strat->S[j],
1883 strat->lenS[j] /*pLength(strat->S[j]) */ ,
1884 strat->kNoether);
1885 number m2 = nMult (m, coef);
1886 nDelete (&m);
1887 m = m2;
1888 nDelete (&coef);
1889 h = kBucketGetLm (P.bucket);
1890
1891 if(h == NULL)
1892 {
1893 len = 0;
1894 kBucketDestroy (&P.bucket);
1895 return NULL;
1896 }
1897 P.p = h;
1898 P.t_p = NULL;
1899 P.SetShortExpVector ();
1900#ifdef KDEBUG
1901 if(TEST_OPT_DEBUG)
1902 {
1903 PrintS ("\nto:");
1904 wrp (h);
1905 PrintLn ();
1906 }
1907#endif
1908 }
1909 else
1910 {
1911 kBucketClear (P.bucket, &(P.p), &len);
1912 kBucketDestroy (&P.bucket);
1913 pNormalize (P.p);
1914 assume (len == (pLength (P.p)));
1915 return P.p;
1916 }
1917 }
1918}
poly kNoether
Definition: kutil.h:331
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
Definition: kbuckets.cc:1085
#define nNormalize(n)
Definition: numbers.h:30
#define nMult(n1, n2)
Definition: numbers.h:17
#define TEST_OPT_DEBUG
Definition: options.h:108
#define pNormalize(p)
Definition: polys.h:317
void PrintLn()
Definition: reporter.cc:310

◆ redNFTail()

static poly redNFTail ( poly  h,
const int  sl,
kStrategy  strat,
int  len 
)
static

Definition at line 3019 of file tgb.cc.

3020{
3021 if(h == NULL)
3022 return NULL;
3023 pTest (h);
3024 if(0 > sl)
3025 return h;
3026 if(pNext (h) == NULL)
3027 return h;
3029
3030 int j;
3031 poly res = h;
3032 poly act = res;
3033 LObject P (pNext (h));
3034 pNext (res) = NULL;
3035 P.bucket = kBucketCreate (currRing);
3036 len--;
3037 h = P.p;
3038 if(len <= 0)
3039 len = pLength (h);
3040 kBucketInit (P.bucket, h /*P.p */ , len /*pLength(P.p) */ );
3041 pTest (h);
3042 loop
3043 {
3044 P.p = h;
3045 P.t_p = NULL;
3046 P.SetShortExpVector ();
3047 loop
3048 {
3049 //int dummy=strat->sl;
3050 j = kFindDivisibleByInS_easy (strat, P.p, P.sev); //kFindDivisibleByInS(strat,&dummy,&P);
3051 if(j >= 0)
3052 {
3053#ifdef REDTAIL_PROT
3054 PrintS ("r");
3055#endif
3056 nNormalize (pGetCoeff (P.p));
3057#ifdef KDEBUG
3058 if(TEST_OPT_DEBUG)
3059 {
3060 PrintS ("red tail:");
3061 wrp (h);
3062 PrintS (" with ");
3063 wrp (strat->S[j]);
3064 }
3065#endif
3066 number coef;
3067 pTest (strat->S[j]);
3068#ifdef HAVE_PLURAL
3069 if(nc)
3070 {
3071 nc_kBucketPolyRed_Z (P.bucket, strat->S[j], &coef);
3072 }
3073 else
3074#endif
3075 coef = kBucketPolyRed (P.bucket, strat->S[j],
3076 strat->lenS[j] /*pLength(strat->S[j]) */ ,
3077 strat->kNoether);
3078 res=__p_Mult_nn (res, coef, currRing);
3079 nDelete (&coef);
3080 h = kBucketGetLm (P.bucket);
3081 if(h == NULL)
3082 {
3083#ifdef REDTAIL_PROT
3084 PrintS (" ");
3085#endif
3086 kBucketDestroy (&P.bucket);
3087 return res;
3088 }
3089 P.p = h;
3090 P.t_p = NULL;
3091 P.SetShortExpVector ();
3092#ifdef KDEBUG
3093 if(TEST_OPT_DEBUG)
3094 {
3095 PrintS ("\nto tail:");
3096 wrp (h);
3097 PrintLn ();
3098 }
3099#endif
3100 }
3101 else
3102 {
3103#ifdef REDTAIL_PROT
3104 PrintS ("n");
3105#endif
3106 break;
3107 }
3108 } /* end loop current mon */
3109 // poly tmp=pHead(h /*kBucketGetLm(P.bucket)*/);
3110 //act->next=tmp;pIter(act);
3111 act->next = kBucketExtractLm (P.bucket);
3112 pIter (act);
3113 h = kBucketGetLm (P.bucket);
3114 if(h == NULL)
3115 {
3116#ifdef REDTAIL_PROT
3117 PrintS (" ");
3118#endif
3119 kBucketDestroy (&P.bucket);
3120 return res;
3121 }
3122 pTest (h);
3123 }
3124}
STATIC_VAR scmon act
Definition: hdegree.cc:1151
poly kBucketExtractLm(kBucket_pt bucket)
Definition: kbuckets.cc:511
static void nc_kBucketPolyRed_Z(kBucket_pt b, poly p, number *c)
Definition: nc.h:286
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:931
#define pTest(p)
Definition: polys.h:415

◆ redTailShort()

static poly redTailShort ( poly  h,
kStrategy  strat 
)
static

Definition at line 1920 of file tgb.cc.

1921{
1922 if(h == NULL)
1923 return NULL; //n_Init(1,currRing);
1925 {
1926 bit_reduce (pNext (h), strat->tailRing);
1927 }
1928 int i;
1929 int len = pLength (h);
1930 for(i = 0; i <= strat->sl; i++)
1931 {
1932 if((strat->lenS[i] > 2)
1933 || ((strat->lenSw != NULL) && (strat->lenSw[i] > 2)))
1934 break;
1935 }
1936 return (redNFTail (h, i - 1, strat, len));
1937}
ring tailRing
Definition: kutil.h:346
void bit_reduce(poly &f, ring r)
Definition: digitech.cc:15

◆ replace_pair()

static void replace_pair ( int &  i,
int &  j,
slimgb_alg c 
)
static

Definition at line 1215 of file tgb.cc.

1216{
1217 if(i < 0)
1218 return;
1219 c->soon_free = NULL;
1220 int syz_deg;
1221 poly lm = pOne ();
1222
1223 pLcm (c->S->m[i], c->S->m[j], lm);
1224 pSetm (lm);
1225
1226 int *i_con = make_connections (i, j, lm, c);
1227
1228 for(int n = 0; ((n < c->n) && (i_con[n] >= 0)); n++)
1229 {
1230 if(i_con[n] == j)
1231 {
1232 now_t_rep (i, j, c);
1233 omFree (i_con);
1234 p_Delete (&lm, c->r);
1235 return;
1236 }
1237 }
1238
1239 int *j_con = make_connections (j, i, lm, c);
1240
1241// if(c->n>1)
1242// {
1243// if (i_con[1]>=0)
1244// i=i_con[1];
1245// else
1246// {
1247// if (j_con[1]>=0)
1248// j=j_con[1];
1249// }
1250 // }
1251
1252 int sugar = syz_deg = c->pTotaldegree (lm);
1253
1254 p_Delete (&lm, c->r);
1255 if(c->T_deg_full) //Sugar
1256 {
1257 int t_i = c->T_deg_full[i] - c->T_deg[i];
1258 int t_j = c->T_deg_full[j] - c->T_deg[j];
1259 sugar += si_max (t_i, t_j);
1260 //Print("\n max: %d\n",max(t_i,t_j));
1261 }
1262
1263 for(int m = 0; ((m < c->n) && (i_con[m] >= 0)); m++)
1264 {
1265 if(c->T_deg_full != NULL)
1266 {
1267 int s1 = c->T_deg_full[i_con[m]] + syz_deg - c->T_deg[i_con[m]];
1268 if(s1 > sugar)
1269 continue;
1270 }
1271 if(c->weighted_lengths[i_con[m]] < c->weighted_lengths[i])
1272 i = i_con[m];
1273 }
1274 for(int m = 0; ((m < c->n) && (j_con[m] >= 0)); m++)
1275 {
1276 if(c->T_deg_full != NULL)
1277 {
1278 int s1 = c->T_deg_full[j_con[m]] + syz_deg - c->T_deg[j_con[m]];
1279 if(s1 > sugar)
1280 continue;
1281 }
1282 if(c->weighted_lengths[j_con[m]] < c->weighted_lengths[j])
1283 j = j_con[m];
1284 }
1285
1286 //can also try dependend search
1287 omFree (i_con);
1288 omFree (j_con);
1289 return;
1290}
int_pair_node * soon_free
Definition: tgb_internal.h:229

◆ search_red_object_pos()

int search_red_object_pos ( red_object a,
int  top,
red_object key 
)

Definition at line 4641 of file tgb.cc.

4642{
4643 int an = 0;
4644 int en = top;
4645 if(top == -1)
4646 return 0;
4647 if(pLmCmp (key->p, a[top].p) == 1)
4648 return top + 1;
4649 int i;
4650 loop
4651 {
4652 if(an >= en - 1)
4653 {
4654 if(pLmCmp (key->p, a[an].p) == -1)
4655 return an;
4656 return en;
4657 }
4658 i = (an + en) / 2;
4659 if(pLmCmp (key->p, a[i].p) == -1)
4660 en = i;
4661 else
4662 an = i;
4663 }
4664}

◆ shorten_tails()

static void shorten_tails ( slimgb_alg c,
poly  monom 
)
static

Definition at line 3759 of file tgb.cc.

3760{
3761 return;
3762// BOOLEAN corr=lenS_correct(c->strat);
3763 for(int i = 0; i < c->n; i++)
3764 {
3765 //enter tail
3766
3767 if(c->S->m[i] == NULL)
3768 continue;
3769 poly tail = c->S->m[i]->next;
3770 poly prev = c->S->m[i];
3771 BOOLEAN did_something = FALSE;
3772 while((tail != NULL) && (pLmCmp (tail, monom) >= 0))
3773 {
3774 if(p_LmDivisibleBy (monom, tail, c->r))
3775 {
3776 did_something = TRUE;
3777 prev->next = tail->next;
3778 tail->next = NULL;
3779 p_Delete (&tail, c->r);
3780 tail = prev;
3781 //PrintS("Shortened");
3782 c->lengths[i]--;
3783 }
3784 prev = tail;
3785 tail = tail->next;
3786 }
3787 if(did_something)
3788 {
3789 int new_pos;
3790 wlen_type q;
3791 q = pQuality (c->S->m[i], c, c->lengths[i]);
3792 new_pos = simple_posInS (c->strat, c->S->m[i], c->lengths[i], q);
3793
3794 int old_pos = -1;
3795 //assume new_pos<old_pos
3796 for(int z = 0; z <= c->strat->sl; z++)
3797 {
3798 if(c->strat->S[z] == c->S->m[i])
3799 {
3800 old_pos = z;
3801 break;
3802 }
3803 }
3804 if(old_pos == -1)
3805 for(int z = new_pos - 1; z >= 0; z--)
3806 {
3807 if(c->strat->S[z] == c->S->m[i])
3808 {
3809 old_pos = z;
3810 break;
3811 }
3812 }
3813 assume (old_pos >= 0);
3814 assume (new_pos <= old_pos);
3815 assume (pLength (c->strat->S[old_pos]) == c->lengths[i]);
3816 c->strat->lenS[old_pos] = c->lengths[i];
3817 if(c->strat->lenSw)
3818 c->strat->lenSw[old_pos] = q;
3819 if(new_pos < old_pos)
3820 move_forward_in_S (old_pos, new_pos, c->strat);
3821 length_one_crit (c, i, c->lengths[i]);
3822 }
3823 }
3824}

◆ simple_posInS()

static int simple_posInS ( kStrategy  strat,
poly  p,
int  len,
wlen_type  wlen 
)
static

Definition at line 1308 of file tgb.cc.

1309{
1310 if(strat->sl == -1)
1311 return 0;
1312 if(strat->lenSw)
1313 return pos_helper (strat, p, (wlen_type) wlen, (wlen_set) strat->lenSw,
1314 strat->S);
1315 return pos_helper (strat, p, len, strat->lenS, strat->S);
1316}
wlen_type * wlen_set
Definition: kutil.h:55
int pos_helper(kStrategy strat, poly p, len_type len, set_type setL, polyset set)
Definition: tgb_internal.h:383

◆ simplify_poly()

static void simplify_poly ( poly  p,
ring  r 
)
static

Definition at line 59 of file tgb.cc.

60{
61 assume (r == currRing);
63 {
64 p_Cleardenom (p, r);
65 //includes p_Content(p,r);
66 }
67 else
68 pNorm (p);
69}

◆ slim_nsize()

int slim_nsize ( number  n,
ring  r 
)

Definition at line 73 of file tgb.cc.

74{
75 if(rField_is_Zp (r))
76 {
77 return 1;
78 }
79 if(rField_is_Q (r))
80 {
81 return nlQlogSize (n, r->cf);
82 }
83 else
84 {
85 return n_Size (n, r->cf);
86 }
87}
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...
Definition: coeffs.h:571
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:502

◆ sort_region_down()

static void sort_region_down ( red_object los,
int  l,
int  u,
slimgb_alg  
)
static

Definition at line 4666 of file tgb.cc.

4667{
4668 int r_size = u - l + 1;
4669 qsort (los + l, r_size, sizeof (red_object), red_object_better_gen);
4670 int i;
4671 int *new_indices = (int *) omalloc ((r_size) * sizeof (int));
4672 int bound = 0;
4673 BOOLEAN at_end = FALSE;
4674 for(i = l; i <= u; i++)
4675 {
4676 if(!(at_end))
4677 {
4678 bound = new_indices[i - l] =
4679 bound + search_red_object_pos (los + bound, l - bound - 1, los + i);
4680 if(bound == l)
4681 at_end = TRUE;
4682 }
4683 else
4684 {
4685 new_indices[i - l] = l;
4686 }
4687 }
4688 red_object *los_region =
4689 (red_object *) omalloc (sizeof (red_object) * (u - l + 1));
4690 for(int i = 0; i < r_size; i++)
4691 {
4692 new_indices[i] += i;
4693 los_region[i] = los[l + i];
4694 assume ((i == 0) || (new_indices[i] > new_indices[i - 1]));
4695 }
4696
4697 i = r_size - 1;
4698 int j = u;
4699 int j2 = l - 1;
4700 while(i >= 0)
4701 {
4702 if(new_indices[i] == j)
4703 {
4704 los[j] = los_region[i];
4705 i--;
4706 j--;
4707 }
4708 else
4709 {
4710 assume (new_indices[i] < j);
4711 los[j] = los[j2];
4712 assume (j2 >= 0);
4713 j2--;
4714 j--;
4715 }
4716 }
4717 omFree (los_region);
4718 omFree (new_indices);
4719}
int search_red_object_pos(red_object *a, int top, red_object *key)
Definition: tgb.cc:4641

◆ spn_merge()

sorted_pair_node ** spn_merge ( sorted_pair_node **  p,
int  pn,
sorted_pair_node **  q,
int  qn,
slimgb_alg c 
)

Definition at line 751 of file tgb.cc.

753{
754 int i;
755 int *a = (int *) omalloc (qn * sizeof (int));
756// int mc;
757// PrintS("Debug\n");
758// for(mc=0;mc<qn;mc++)
759// {
760// wrp(q[mc]->lcm_of_lm);
761// PrintS("\n");
762// }
763// PrintS("Debug they are in\n");
764// for(mc=0;mc<pn;mc++)
765// {
766// wrp(p[mc]->lcm_of_lm);
767// PrintS("\n");
768// }
769 int lastpos = 0;
770 for(i = 0; i < qn; i++)
771 {
772 lastpos = posInPairs (p, pn, q[i], c, si_max (lastpos - 1, 0));
773 // cout<<lastpos<<"\n";
774 a[i] = lastpos;
775 }
776 if((pn + qn) > c->max_pairs)
777 {
778 p =
780 2 * (pn +
781 qn) *
782 sizeof (sorted_pair_node *));
783 c->max_pairs = 2 * (pn + qn);
784 }
785 for(i = qn - 1; i >= 0; i--)
786 {
787 size_t size;
788 if(qn - 1 > i)
789 size = (a[i + 1] - a[i]) * sizeof (sorted_pair_node *);
790 else
791 size = (pn - a[i]) * sizeof (sorted_pair_node *); //as indices begin with 0
792 memmove (p + a[i] + (1 + i), p + a[i], size);
793 p[a[i] + i] = q[i];
794 }
795 omFree (a);
796 return p;
797}
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
static int posInPairs(sorted_pair_node **p, int pn, sorted_pair_node *qe, slimgb_alg *c, int an=0)
Definition: tgb.cc:711

◆ state_is()

static BOOLEAN state_is ( calc_state  state,
const int &  i,
const int &  j,
slimgb_alg c 
)
static

Definition at line 3979 of file tgb.cc.

3981{
3982 assume (0 <= arg_i);
3983 assume (0 <= arg_j);
3984 assume (arg_i < c->n);
3985 assume (arg_j < c->n);
3986 if(arg_i == arg_j)
3987 {
3988 return (TRUE);
3989 }
3990 if(arg_i > arg_j)
3991 {
3992 return (c->states[arg_i][arg_j] == state);
3993 }
3994 else
3995 return (c->states[arg_j][arg_i] == state);
3996}

◆ super_clean_top_of_pair_list()

static void super_clean_top_of_pair_list ( slimgb_alg c)
static

Definition at line 3952 of file tgb.cc.

3953{
3954 while((c->pair_top >= 0)
3955 && (c->apairs[c->pair_top]->i >= 0)
3956 &&
3958 (c->apairs[c->pair_top]->j, c->apairs[c->pair_top]->i, c)))
3959 {
3961 c->pair_top--;
3962 }
3963}
BOOLEAN good_has_t_rep(int i, int j, slimgb_alg *c)
Definition: tgb.cc:876

◆ t_rep_gb()

ideal t_rep_gb ( const ring  r,
ideal  arg_I,
int  syz_comp,
BOOLEAN  F4_mode 
)

Definition at line 3602 of file tgb.cc.

3603{
3604 assume (r == currRing);
3605 ring orig_ring = r;
3606 int pos;
3607 ring new_ring = rAssure_TDeg (orig_ring, pos);
3608 ideal s_h;
3609 if(orig_ring != new_ring)
3610 {
3611 rChangeCurrRing (new_ring);
3612 s_h = idrCopyR_NoSort (arg_I, orig_ring, new_ring);
3613 /*int i;
3614 for(i=0;i<IDELEMS(s_h);i++)
3615 {
3616 poly p=s_h->m[i];
3617 while(p)
3618 {
3619 p_Setm(p,new_ring);
3620 pIter(p);
3621 }
3622 } */
3623 }
3624 else
3625 {
3626 s_h = id_Copy (arg_I, orig_ring);
3627 }
3628 idTest (s_h);
3629
3630 ideal s_result = do_t_rep_gb (new_ring, s_h, syz_comp, F4_mode, pos);
3631 ideal result;
3632 if(orig_ring != new_ring)
3633 {
3634 idTest (s_result);
3635 rChangeCurrRing (orig_ring);
3636 result = idrMoveR_NoSort (s_result, new_ring, orig_ring);
3637
3638 idTest (result);
3639 //rChangeCurrRing(new_ring);
3640 rDelete(new_ring);
3641 //rChangeCurrRing(orig_ring);
3642 }
3643 else
3644 result = s_result;
3645 idTest (result);
3646 return result;
3647}
return result
Definition: facAbsBiFact.cc:75
ideal id_Copy(ideal h1, const ring r)
copy an ideal
#define idTest(id)
Definition: ideals.h:47
void rChangeCurrRing(ring r)
Definition: polys.cc:15
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:260
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:204
ring rAssure_TDeg(ring r, int &pos)
Definition: ring.cc:4501
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:449
ideal do_t_rep_gb(ring, ideal arg_I, int syz_comp, BOOLEAN F4_mode, int deg_pos)
Definition: tgb.cc:3650

◆ terms_sort_crit()

int terms_sort_crit ( const void *  a,
const void *  b 
)

Definition at line 2030 of file tgb.cc.

2031{
2032 return -pLmCmp (*((poly *) a), *((poly *) b));
2033}

◆ tgb_pair_better_gen()

static int tgb_pair_better_gen ( const void *  ap,
const void *  bp 
)
static

Definition at line 4033 of file tgb.cc.

4034{
4036 sorted_pair_node *b = *((sorted_pair_node **) bp);
4037 assume ((a->i > a->j) || (a->i < 0));
4038 assume ((b->i > b->j) || (b->i < 0));
4039 if(a->deg < b->deg)
4040 return -1;
4041 if(a->deg > b->deg)
4042 return 1;
4043
4044 int comp = pLmCmp (a->lcm_of_lm, b->lcm_of_lm);
4045
4046 if(comp == 1)
4047 return 1;
4048 if(-1 == comp)
4049 return -1;
4050 if(a->expected_length < b->expected_length)
4051 return -1;
4052 if(a->expected_length > b->expected_length)
4053 return 1;
4054 if(a->i + a->j < b->i + b->j)
4055 return -1;
4056 if(a->i + a->j > b->i + b->j)
4057 return 1;
4058 if(a->i < b->i)
4059 return -1;
4060 if(a->i > b->i)
4061 return 1;
4062 return 0;
4063}

◆ tgb_pair_better_gen2()

int tgb_pair_better_gen2 ( const void *  ap,
const void *  bp 
)

Definition at line 680 of file tgb.cc.

681{
682 return (-tgb_pair_better_gen (ap, bp));
683}
static int tgb_pair_better_gen(const void *ap, const void *bp)
Definition: tgb.cc:4033

◆ top_pair()

sorted_pair_node * top_pair ( slimgb_alg c)

Definition at line 3920 of file tgb.cc.

3921{
3922 while(c->pair_top >= 0)
3923 {
3924 super_clean_top_of_pair_list (c); //yeah, I know, it's odd that I use a different proc here
3925 if((c->is_homog) && (c->pair_top >= 0)
3926 && (c->apairs[c->pair_top]->deg >= c->lastCleanedDeg + 2))
3927 {
3928 int upper = c->apairs[c->pair_top]->deg - 1;
3929 c->cleanDegs (c->lastCleanedDeg + 1, upper);
3930 c->lastCleanedDeg = upper;
3931 }
3932 else
3933 {
3934 break;
3935 }
3936 }
3937
3938 if(c->pair_top < 0)
3939 return NULL;
3940 else
3941 return (c->apairs[c->pair_top]);
3942}
int lastCleanedDeg
Definition: tgb_internal.h:261
void cleanDegs(int lower, int upper)
Definition: tgb.cc:3838
static void super_clean_top_of_pair_list(slimgb_alg *c)
Definition: tgb.cc:3952

◆ trivial_syzygie()

static BOOLEAN trivial_syzygie ( int  pos1,
int  pos2,
poly  bound,
slimgb_alg c 
)
static

Definition at line 800 of file tgb.cc.

801{
802 poly p1 = c->S->m[pos1];
803 poly p2 = c->S->m[pos2];
804
805 if(pGetComp (p1) > 0 || pGetComp (p2) > 0)
806 return FALSE;
807 int i = 1;
808 poly m = NULL;
809 poly gcd1 = c->gcd_of_terms[pos1];
810 poly gcd2 = c->gcd_of_terms[pos2];
811
812 if((gcd1 != NULL) && (gcd2 != NULL))
813 {
814 gcd1->next = gcd2; //may ordered incorrect
815 m = gcd_of_terms (gcd1, c->r);
816 gcd1->next = NULL;
817 }
818 if(m == NULL)
819 {
820 loop
821 {
822 if(pGetExp (p1, i) + pGetExp (p2, i) > pGetExp (bound, i))
823 return FALSE;
824 if(i == (currRing->N))
825 {
826 //PrintS("trivial");
827 return TRUE;
828 }
829 i++;
830 }
831 }
832 else
833 {
834 loop
835 {
836 if(pGetExp (p1, i) - pGetExp (m, i) + pGetExp (p2, i) >
837 pGetExp (bound, i))
838 {
839 pDelete (&m);
840 return FALSE;
841 }
842 if(i == (currRing->N))
843 {
844 pDelete (&m);
845 //PrintS("trivial");
846 return TRUE;
847 }
848 i++;
849 }
850 }
851}

Variable Documentation

◆ bundle_size

const int bundle_size = 100
static

Definition at line 36 of file tgb.cc.

◆ bundle_size_noro

const int bundle_size_noro = 10000
static

Definition at line 37 of file tgb.cc.

◆ delay_factor

const int delay_factor = 3
static

Definition at line 38 of file tgb.cc.

◆ lm_bin

STATIC_VAR omBin lm_bin = NULL

Definition at line 41 of file tgb.cc.