My Project
Data Structures | Macros | Typedefs | Enumerations | Functions
tgb_internal.h File Reference
#include "omalloc/omalloc.h"
#include <algorithm>
#include <vector>
#include <stdlib.h>
#include "misc/options.h"
#include "coeffs/modulop.h"
#include "polys/monomials/p_polys.h"
#include "polys/monomials/ring.h"
#include "polys/kbuckets.h"
#include "kernel/ideals.h"
#include "kernel/polys.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/GBEngine/kInline.h"
#include "kernel/GBEngine/kstd1.h"
#include "coeffs/modulop_inl.h"

Go to the source code of this file.

Data Structures

class  PolySimple
 
class  MonRedResNP< number_type >
 
struct  sorted_pair_node
 
struct  poly_list_node
 
struct  int_pair_node
 
struct  monom_poly
 
struct  mp_array_list
 
struct  poly_array_list
 
class  slimgb_alg
 
class  red_object
 
class  reduction_step
 makes on each red_object in a region a single_step More...
 
class  simple_reducer
 
struct  find_erg
 
class  NoroCacheNode
 
class  DenseRow
 
class  SparseRow< number_type >
 
class  DataNoroCacheNode< number_type >
 
class  TermNoroDataNode< number_type >
 
class  NoroCache< number_type >
 
class  CoefIdx< number_type >
 
class  ModPMatrixProxyOnArray< number_type >
 
class  ModPMatrixBackSubstProxyOnArray< number_type >
 

Macros

#define USE_NORO   1
 
#define FULLREDUCTIONS
 
#define REDTAIL_S
 
#define PAR_N   100
 
#define PAR_N_F4   5000
 
#define AC_NEW_MIN   2
 
#define AC_FLATTEN   1
 
#define NORO_CACHE   1
 
#define NORO_SPARSE_ROWS_PRE   1
 
#define NORO_NON_POLY   1
 
#define slim_prec_cast(a)   (unsigned int) (unsigned long) (a)
 
#define F4mat_to_number_type(a)   (number_type) slim_prec_cast(a)
 

Typedefs

typedef unsigned short tgb_uint16
 
typedef unsigned char tgb_uint8
 
typedef unsigned int tgb_uint32
 

Enumerations

enum  calc_state { UNCALCULATED , HASTREP }
 

Functions

template<class len_type , class set_type >
int pos_helper (kStrategy strat, poly p, len_type len, set_type setL, polyset set)
 
void free_sorted_pair_node (sorted_pair_node *s, const ring r)
 
ideal do_t_rep_gb (ring r, 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)
 
void clean_top_of_pair_list (slimgb_alg *c)
 
int slim_nsize (number n, ring r)
 
sorted_pair_nodequick_pop_pair (slimgb_alg *c)
 
sorted_pair_nodetop_pair (slimgb_alg *c)
 
sorted_pair_node ** add_to_basis_ideal_quotient (poly h, slimgb_alg *c, int *ip)
 
sorted_pair_node ** spn_merge (sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
 
int kFindDivisibleByInS_easy (kStrategy strat, const red_object &obj)
 
int tgb_pair_better_gen2 (const void *ap, const void *bp)
 
int kFindDivisibleByInS_easy (kStrategy strat, poly p, long sev)
 
template<class number_type >
SparseRow< number_type > * noro_red_to_non_poly_t (poly p, int &len, NoroCache< number_type > *cache, slimgb_alg *c)
 
template<class number_type >
MonRedResNP< number_type > noro_red_mon_to_non_poly (poly t, NoroCache< number_type > *cache, slimgb_alg *c)
 
template<class number_type >
SparseRow< number_type > * convert_to_sparse_row (number_type *temp_array, int temp_size, int non_zeros)
 
template<class number_type >
void add_coef_times_sparse (number_type *const temp_array, int, SparseRow< number_type > *row, number coef)
 
template<class number_type >
void add_coef_times_dense (number_type *const temp_array, int, const number_type *row, int len, number coef)
 
template<class number_type >
void add_dense (number_type *const temp_array, int, const number_type *row, int len)
 
template<class number_type >
void sub_dense (number_type *const temp_array, int, const number_type *row, int len)
 
template<class number_type >
void add_sparse (number_type *const temp_array, int, SparseRow< number_type > *row)
 
template<class number_type >
void sub_sparse (number_type *const temp_array, int, SparseRow< number_type > *row)
 
template<class number_type >
SparseRow< number_type > * noro_red_to_non_poly_dense (MonRedResNP< number_type > *mon, int len, NoroCache< number_type > *cache)
 
template<class number_type >
void write_coef_times_xx_idx_to_buffer (CoefIdx< number_type > *const pairs, int &pos, int *const idx_array, number_type *const coef_array, const int rlen, const number coef)
 
template<class number_type >
void write_coef_times_xx_idx_to_buffer_dense (CoefIdx< number_type > *const pairs, int &pos, number_type *const coef_array, const int rlen, const number coef)
 
template<class number_type >
void write_coef_idx_to_buffer_dense (CoefIdx< number_type > *const pairs, int &pos, number_type *const coef_array, const int rlen)
 
template<class number_type >
void write_minus_coef_idx_to_buffer_dense (CoefIdx< number_type > *const pairs, int &pos, number_type *const coef_array, const int rlen)
 
template<class number_type >
void write_coef_idx_to_buffer (CoefIdx< number_type > *const pairs, int &pos, int *const idx_array, number_type *const coef_array, const int rlen)
 
template<class number_type >
void write_minus_coef_idx_to_buffer (CoefIdx< number_type > *const pairs, int &pos, int *const idx_array, number_type *const coef_array, const int rlen)
 
template<class number_type >
SparseRow< number_type > * noro_red_to_non_poly_sparse (MonRedResNP< number_type > *mon, int len, NoroCache< number_type > *cache)
 
wlen_type pELength (poly p, ring r)
 
int terms_sort_crit (const void *a, const void *b)
 
template<class number_type >
void write_poly_to_row (number_type *row, poly h, poly *terms, int tn, ring r)
 
template<class number_type >
poly row_to_poly (number_type *row, poly *terms, int tn, ring r)
 
template<class number_type >
int modP_lastIndexRow (number_type *row, int ncols)
 
template<class number_type >
int term_nodes_sort_crit (const void *a, const void *b)
 
template<class number_type >
void simplest_gauss_modp (number_type *a, int nrows, int ncols)
 
template<class number_type >
void noro_step (poly *p, int &pn, slimgb_alg *c)
 

Data Structure Documentation

◆ sorted_pair_node

struct sorted_pair_node

Definition at line 144 of file tgb_internal.h.

Data Fields
int deg
wlen_type expected_length
int i
int j
poly lcm_of_lm

◆ poly_list_node

struct poly_list_node

Definition at line 168 of file tgb_internal.h.

Data Fields
poly_list_node * next
poly p

◆ int_pair_node

struct int_pair_node

Definition at line 174 of file tgb_internal.h.

Data Fields
int a
int b
int_pair_node * next

◆ monom_poly

struct monom_poly

Definition at line 180 of file tgb_internal.h.

Data Fields
poly f
poly m

◆ mp_array_list

struct mp_array_list

Definition at line 185 of file tgb_internal.h.

Data Fields
monom_poly * mp
mp_array_list * next
int size

◆ poly_array_list

struct poly_array_list

Definition at line 193 of file tgb_internal.h.

Data Fields
poly_array_list * next
poly * p
int size

◆ find_erg

struct find_erg

Definition at line 372 of file tgb_internal.h.

Data Fields
poly expand
int expand_length
BOOLEAN fromS
int reduce_by
int to_reduce_l
int to_reduce_u

◆ TermNoroDataNode

class TermNoroDataNode
template<class number_type>
class TermNoroDataNode< number_type >

Definition at line 569 of file tgb_internal.h.

Data Fields
DataNoroCacheNode< number_type > * node
poly t

Macro Definition Documentation

◆ AC_FLATTEN

#define AC_FLATTEN   1

Definition at line 23 of file tgb_internal.h.

◆ AC_NEW_MIN

#define AC_NEW_MIN   2

Definition at line 22 of file tgb_internal.h.

◆ F4mat_to_number_type

#define F4mat_to_number_type (   a)    (number_type) slim_prec_cast(a)

Definition at line 414 of file tgb_internal.h.

◆ FULLREDUCTIONS

#define FULLREDUCTIONS

Definition at line 15 of file tgb_internal.h.

◆ NORO_CACHE

#define NORO_CACHE   1

Definition at line 29 of file tgb_internal.h.

◆ NORO_NON_POLY

#define NORO_NON_POLY   1

Definition at line 31 of file tgb_internal.h.

◆ NORO_SPARSE_ROWS_PRE

#define NORO_SPARSE_ROWS_PRE   1

Definition at line 30 of file tgb_internal.h.

◆ PAR_N

#define PAR_N   100

Definition at line 20 of file tgb_internal.h.

◆ PAR_N_F4

#define PAR_N_F4   5000

Definition at line 21 of file tgb_internal.h.

◆ REDTAIL_S

#define REDTAIL_S

Definition at line 19 of file tgb_internal.h.

◆ slim_prec_cast

#define slim_prec_cast (   a)    (unsigned int) (unsigned long) (a)

Definition at line 413 of file tgb_internal.h.

◆ USE_NORO

#define USE_NORO   1

Definition at line 10 of file tgb_internal.h.

Typedef Documentation

◆ tgb_uint16

typedef unsigned short tgb_uint16

Definition at line 415 of file tgb_internal.h.

◆ tgb_uint32

typedef unsigned int tgb_uint32

Definition at line 417 of file tgb_internal.h.

◆ tgb_uint8

typedef unsigned char tgb_uint8

Definition at line 416 of file tgb_internal.h.

Enumeration Type Documentation

◆ calc_state

enum calc_state
Enumerator
UNCALCULATED 
HASTREP 

Definition at line 311 of file tgb_internal.h.

312 {
314 HASTREP//,
315 //UNIMPORTANT,
316 //SOONTREP
317 };
@ UNCALCULATED
Definition: tgb_internal.h:313
@ HASTREP
Definition: tgb_internal.h:314

Function Documentation

◆ add_coef_times_dense()

template<class number_type >
void add_coef_times_dense ( number_type *const  temp_array,
int  ,
const number_type *  row,
int  len,
number  coef 
)

Definition at line 939 of file tgb_internal.h.

945{
946 int j;
947 const number_type* const coef_array=row;
948 //int* const idx_array=row->idx_array;
949 //const int len=temp_size;
950 tgb_uint32 buffer[256];
951 const tgb_uint32 prime=n_GetChar(currRing->cf);
952 const tgb_uint32 c=F4mat_to_number_type(coef);
953 assume(!(npIsZero(coef,currRing->cf)));
954 for(j=0;j<len;j=j+256)
955 {
956 const int bound=std::min(j+256,len);
957 int i;
958 int bpos=0;
959 for(i=j;i<bound;i++)
960 {
961 buffer[bpos++]=coef_array[i];
962 }
963 int bpos_bound=bound-j;
964 for(i=0;i<bpos_bound;i++)
965 {
966 buffer[i]*=c;
967 }
968 for(i=0;i<bpos_bound;i++)
969 {
970 buffer[i]=buffer[i]%prime;
971 }
972 bpos=0;
973 for(i=j;i<bound;i++)
974 {
975 //int idx=idx_array[i];
976 assume(bpos<256);
977 //assume(!(npIsZero((number) buffer[bpos])));
978 temp_array[i]=F4mat_to_number_type(npAddM((number)(long) temp_array[i], (number)(long) buffer[bpos++],currRing->cf));
979 #ifndef SING_NDEBUG
980 assume(i<temp_size);
981 #endif
982 }
983
984 }
985}
int i
Definition: cfEzgcd.cc:132
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
int j
Definition: facHensel.cc:110
static int min(int a, int b)
Definition: fast_mult.cc:268
#define assume(x)
Definition: mod2.h:387
static number npAddM(number a, number b, const coeffs r)
Definition: modulop.h:116
static BOOLEAN npIsZero(number a, const coeffs r)
Definition: modulop_inl.h:38
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
unsigned int tgb_uint32
Definition: tgb_internal.h:417
#define F4mat_to_number_type(a)
Definition: tgb_internal.h:414

◆ add_coef_times_sparse()

template<class number_type >
void add_coef_times_sparse ( number_type *const  temp_array,
int  ,
SparseRow< number_type > *  row,
number  coef 
)

Definition at line 891 of file tgb_internal.h.

897{
898 int j;
899 number_type* const coef_array=row->coef_array;
900 int* const idx_array=row->idx_array;
901 const int len=row->len;
902 tgb_uint32 buffer[256];
903 const tgb_uint32 prime=n_GetChar(currRing->cf);
904 const tgb_uint32 c=F4mat_to_number_type(coef);
905 assume(!(npIsZero(coef,currRing->cf)));
906 for(j=0;j<len;j=j+256)
907 {
908 const int bound=std::min(j+256,len);
909 int i;
910 int bpos=0;
911 for(i=j;i<bound;i++)
912 {
913 buffer[bpos++]=coef_array[i];
914 }
915 int bpos_bound=bound-j;
916 for(i=0;i<bpos_bound;i++)
917 {
918 buffer[i]*=c;
919 }
920 for(i=0;i<bpos_bound;i++)
921 {
922 buffer[i]=buffer[i]%prime;
923 }
924 bpos=0;
925 for(i=j;i<bound;i++)
926 {
927 int idx=idx_array[i];
928 assume(bpos<256);
929 assume(!(npIsZero((number)(long) buffer[bpos],currRing->cf)));
930 temp_array[idx]=F4mat_to_number_type(npAddM((number)(long) temp_array[idx], (number)(long) buffer[bpos++],currRing->cf));
931 #ifndef SING_NDEBUG
932 assume(idx<temp_size);
933 #endif
934 }
935
936 }
937}
number_type * coef_array
Definition: tgb_internal.h:504
int * idx_array
Definition: tgb_internal.h:503

◆ add_dense()

template<class number_type >
void add_dense ( number_type *const  temp_array,
int  ,
const number_type *  row,
int  len 
)

Definition at line 987 of file tgb_internal.h.

993{
994 //int j;
995 //const number_type* const coef_array=row;
996 //int* const idx_array=row->idx_array;
997 //const int len=temp_size;
998 //tgb_uint32 buffer[256];
999 //const tgb_uint32 prime=npPrimeM;
1000 //const tgb_uint32 c=F4mat_to_number_type(coef);
1001
1002 int i;
1003 for(i=0;i<len;i++)
1004 {
1005 temp_array[i]=F4mat_to_number_type(npAddM((number)(long) temp_array[i], (number)(long) row[i],currRing->cf));
1006 #ifndef SING_NDEBUG
1007 assume(i<temp_size);
1008 #endif
1009 }
1010
1011}

◆ add_sparse()

template<class number_type >
void add_sparse ( number_type *const  temp_array,
int  ,
SparseRow< number_type > *  row 
)

Definition at line 1039 of file tgb_internal.h.

1043{
1044 int j;
1045
1046 number_type* const coef_array=row->coef_array;
1047 int* const idx_array=row->idx_array;
1048 const int len=row->len;
1049 for(j=0;j<len;j++)
1050 {
1051 int idx=idx_array[j];
1052 temp_array[idx]=F4mat_to_number_type( (number_type)(long)npAddM((number) (long)temp_array[idx],(number)(long) coef_array[j],currRing->cf));
1053 #ifndef SING_NDEBUG
1054 assume(idx<temp_size);
1055 #endif
1056 }
1057}

◆ 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}
#define NULL
Definition: auxiliary.h:104
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
int p
Definition: cfModGcd.cc:4080
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
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 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
#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
void PrintS(const char *s)
Definition: reporter.cc:284
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

◆ 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

◆ convert_to_sparse_row()

template<class number_type >
SparseRow< number_type > * convert_to_sparse_row ( number_type *  temp_array,
int  temp_size,
int  non_zeros 
)

Definition at line 823 of file tgb_internal.h.

824{
826//int pos=0;
827//Print("denseness:%f\n",((double) non_zeros/(double) temp_size));
828number_type* it_coef=res->coef_array;
829int* it_idx=res->idx_array;
830#if 0
831for(i=0;i<cache->nIrreducibleMonomials;i++)
832{
833 if (!(0==temp_array[i]))
834 {
835
836 res->idx_array[pos]=i;
837 res->coef_array[pos]=temp_array[i];
838
839 pos++;
840 non_zeros--;
841 if (non_zeros==0) break;
842 }
843
844}
845#else
846int64* start=(int64*) ((void*)temp_array);
847int64* end;
848const int multiple=sizeof(int64)/sizeof(number_type);
849if (temp_size==0) end=start;
850
851else
852{
853 int temp_size_rounded=temp_size+(multiple-(temp_size%multiple));
854 assume(temp_size_rounded>=temp_size);
855 assume(temp_size_rounded%multiple==0);
856 assume(temp_size_rounded<temp_size+multiple);
857 number_type* nt_end=temp_array+temp_size_rounded;
858 end=(int64*)((void*)nt_end);
859}
860int64* it=start;
861while(it!=end)
862{
863 if UNLIKELY((*it)!=0)
864 {
865 int small_i;
866 const int temp_index=((number_type*)((void*) it))-temp_array;
867 const int bound=temp_index+multiple;
868 number_type c;
869 for(small_i=temp_index;small_i<bound;small_i++)
870 {
871 if((c=temp_array[small_i])!=0)
872 {
873 //res->idx_array[pos]=small_i;
874 //res->coef_array[pos]=temp_array[small_i];
875 (*(it_idx++))=small_i;
876 (*(it_coef++))=c;
877 //pos++;
878 non_zeros--;
879
880 }
881 if UNLIKELY(non_zeros==0) break;
882 }
883
884 }
885 ++it;
886}
887#endif
888return res;
889}
long int64
Definition: auxiliary.h:68
#define UNLIKELY(expression)
Definition: cf_factory.cc:25
CanonicalForm res
Definition: facAbsFact.cc:60

◆ 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
#define TEST_OPT_PROT
Definition: options.h:103
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

◆ 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}

◆ 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
polyset S
Definition: kutil.h:307
int sl
Definition: kutil.h:351
unsigned long * sevS
Definition: kutil.h:323
#define pGetComp(p)
Component.
Definition: polys.h:37
#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

◆ 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}

◆ modP_lastIndexRow()

template<class number_type >
int modP_lastIndexRow ( number_type *  row,
int  ncols 
)

Definition at line 1487 of file tgb_internal.h.

1488{
1489 int lastIndex;
1490 const number_type zero=0;//npInit(0);
1491 for(lastIndex=ncols-1;lastIndex>=0;lastIndex--)
1492 {
1493 if (!(row[lastIndex]==zero))
1494 {
1495 return lastIndex;
1496 }
1497 }
1498 return -1;
1499}
int int ncols
Definition: cf_linsys.cc:32

◆ noro_red_mon_to_non_poly()

template<class number_type >
MonRedResNP< number_type > noro_red_mon_to_non_poly ( poly  t,
NoroCache< number_type > *  cache,
slimgb_alg c 
)

Definition at line 744 of file tgb_internal.h.

745{
746 MonRedResNP<number_type> res_holder;
747
748
750 if (ref!=NULL)
751 {
752 res_holder.coef=p_GetCoeff(t,c->r);
753
754 res_holder.ref=ref;
755 p_Delete(&t,c->r);
756 return res_holder;
757 }
758
759 unsigned long sev=p_GetShortExpVector(t,currRing);
760 int i=kFindDivisibleByInS_easy(c->strat,t,sev);
761 if (i>=0)
762 {
763 number coef_bak=p_GetCoeff(t,c->r);
764
765 p_SetCoeff(t,npInit(1,c->r->cf),c->r);
766 assume(npIsOne(p_GetCoeff(c->strat->S[i],c->r),c->r->cf));
767 number coefstrat=p_GetCoeff(c->strat->S[i],c->r);
768
769
770 poly exp_diff=cache->temp_term;
771 p_ExpVectorDiff(exp_diff,t,c->strat->S[i],c->r);
772 p_SetCoeff(exp_diff,npNegM(npInversM(coefstrat,c->r->cf),c->r->cf),c->r);
773 p_Setm(exp_diff,c->r);
774 assume(c->strat->S[i]!=NULL);
775
776 poly res;
777 res=pp_Mult_mm(pNext(c->strat->S[i]),exp_diff,c->r);
778
779 int len=c->strat->lenS[i]-1;
781 srow=noro_red_to_non_poly_t<number_type>(res,len,cache,c);
782 ref=cache->insert(t,srow);
783 p_Delete(&t,c->r);
784
785
786 res_holder.coef=coef_bak;
787 res_holder.ref=ref;
788 return res_holder;
789
790 } else {
791 number coef_bak=p_GetCoeff(t,c->r);
792 number one=npInit(1, c->r->cf);
793 p_SetCoeff(t,one,c->r);
794
795 res_holder.ref=cache->insertAndTransferOwnerShip(t,c->r);
796 assume(res_holder.ref!=NULL);
797 res_holder.coef=coef_bak;
798
799 return res_holder;
800
801 }
802
803}
DataNoroCacheNode< number_type > * ref
Definition: tgb_internal.h:138
poly temp_term
Definition: tgb_internal.h:579
DataNoroCacheNode< number_type > * getCacheReference(poly term)
DataNoroCacheNode< number_type > * insertAndTransferOwnerShip(poly t, ring)
Definition: tgb_internal.h:633
DataNoroCacheNode< number_type > * insert(poly term, poly nf, int len)
Definition: tgb_internal.h:593
static BOOLEAN npIsOne(number a, const coeffs)
Definition: modulop.h:171
static number npNegM(number a, const coeffs r)
Definition: modulop.h:166
static number npInversM(number c, const coeffs r)
Definition: modulop.h:215
static number npInit(long i, const coeffs r)
Definition: modulop_inl.h:27
#define p_GetCoeff(p, r)
Definition: monomials.h:50
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:991
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1434
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:412
int kFindDivisibleByInS_easy(kStrategy strat, const red_object &obj)
Definition: tgb.cc:685

◆ noro_red_to_non_poly_dense()

template<class number_type >
SparseRow< number_type > * noro_red_to_non_poly_dense ( MonRedResNP< number_type > *  mon,
int  len,
NoroCache< number_type > *  cache 
)

Definition at line 1078 of file tgb_internal.h.

1079{
1080 size_t temp_size_bytes=cache->nIrreducibleMonomials*sizeof(number_type)+8;//use 8bit int for testing
1081 assume(sizeof(int64)==8);
1082 cache->ensureTempBufferSize(temp_size_bytes);
1083 number_type* temp_array=(number_type*) cache->tempBuffer;//omalloc(cache->nIrreducibleMonomials*sizeof(number_type));
1084 int temp_size=cache->nIrreducibleMonomials;
1085 memset(temp_array,0,temp_size_bytes);
1086 number minus_one=npInit(-1,currRing->cf);
1087 int i;
1088 for(i=0;i<len;i++)
1089 {
1090 MonRedResNP<number_type> red=mon[i];
1091 if ( /*(*/ red.ref /*)*/ )
1092 {
1093 if (red.ref->row)
1094 {
1095 SparseRow<number_type>* row=red.ref->row;
1096 number coef=red.coef;
1097 if (row->idx_array)
1098 {
1099 if (!((coef==(number)1L)||(coef==minus_one)))
1100 {
1101 add_coef_times_sparse(temp_array,temp_size,row,coef);
1102 }
1103 else
1104 {
1105 if (coef==(number)1L)
1106 {
1107 add_sparse(temp_array,temp_size,row);
1108 }
1109 else
1110 {
1111 sub_sparse(temp_array,temp_size,row);
1112 }
1113 }
1114 }
1115 else
1116 //TODO: treat, 1,-1
1117 if (!((coef==(number)1L)||(coef==minus_one)))
1118 {
1119 add_coef_times_dense(temp_array,temp_size,row->coef_array,row->len,coef);
1120 }
1121 else
1122 {
1123 if (coef==(number)1L)
1124 add_dense(temp_array,temp_size,row->coef_array,row->len);
1125 else
1126 {
1127 assume(coef==minus_one);
1128 sub_dense(temp_array,temp_size,row->coef_array,row->len);
1129 //add_coef_times_dense(temp_array,temp_size,row->coef_array,row->len,coef);
1130 }
1131 }
1132 }
1133 else
1134 {
1135 if (red.ref->value_len==NoroCache<number_type>::backLinkCode)
1136 {
1137 temp_array[red.ref->term_index]=F4mat_to_number_type( npAddM((number)(long) temp_array[red.ref->term_index],red.coef,currRing->cf));
1138 }
1139 else
1140 {
1141 //PrintS("third case\n");
1142 }
1143 }
1144 }
1145 }
1146 int non_zeros=0;
1147 for(i=0;i<cache->nIrreducibleMonomials;i++)
1148 {
1149 //if (!(temp_array[i]==0))
1150 //{
1151 // non_zeros++;
1152 //}
1153 assume(((temp_array[i]!=0)==0)|| (((temp_array[i]!=0)==1)));
1154 non_zeros+=(temp_array[i]!=0);
1155 }
1156
1157 if (non_zeros==0)
1158 {
1159 //omfree(mon);
1160 return NULL;
1161 }
1162 SparseRow<number_type>* res=new SparseRow<number_type>(temp_size,temp_array);//convert_to_sparse_row(temp_array,temp_size, non_zeros);
1163
1164 //omfree(temp_array);
1165
1166
1167 return res;
1168}
int nIrreducibleMonomials
Definition: tgb_internal.h:692
void ensureTempBufferSize(size_t size)
Definition: tgb_internal.h:656
void * tempBuffer
Definition: tgb_internal.h:694
void add_dense(number_type *const temp_array, int, const number_type *row, int len)
Definition: tgb_internal.h:987
void sub_dense(number_type *const temp_array, int, const number_type *row, int len)
void add_coef_times_sparse(number_type *const temp_array, int, SparseRow< number_type > *row, number coef)
Definition: tgb_internal.h:891
void sub_sparse(number_type *const temp_array, int, SparseRow< number_type > *row)
void add_sparse(number_type *const temp_array, int, SparseRow< number_type > *row)
void add_coef_times_dense(number_type *const temp_array, int, const number_type *row, int len, number coef)
Definition: tgb_internal.h:939

◆ noro_red_to_non_poly_sparse()

template<class number_type >
SparseRow< number_type > * noro_red_to_non_poly_sparse ( MonRedResNP< number_type > *  mon,
int  len,
NoroCache< number_type > *  cache 
)

Definition at line 1268 of file tgb_internal.h.

1269{
1270 int i;
1271 int together=0;
1272 for(i=0;i<len;i++)
1273 {
1274 MonRedResNP<number_type> red=mon[i];
1275 if ((red.ref) &&( red.ref->row))
1276 {
1277 together+=red.ref->row->len;
1278 }
1279 else
1280 {
1281 if ((red.ref) &&(red.ref->value_len==NoroCache<number_type>::backLinkCode))
1282 together++;
1283 }
1284 }
1285 //PrintS("here\n");
1286 if (together==0) return 0;
1287 //PrintS("there\n");
1288 cache->ensureTempBufferSize(together*sizeof(CoefIdx<number_type>));
1289 CoefIdx<number_type>* pairs=(CoefIdx<number_type>*) cache->tempBuffer; //omalloc(together*sizeof(CoefIdx<number_type>));
1290 int pos=0;
1291 const number one=npInit(1, currRing->cf);
1292 const number minus_one=npInit(-1, currRing->cf);
1293 for(i=0;i<len;i++)
1294 {
1295 MonRedResNP<number_type> red=mon[i];
1296 if ((red.ref) &&( red.ref->row))
1297 {
1298 //together+=red.ref->row->len;
1299 int* idx_array=red.ref->row->idx_array;
1300 number_type* coef_array=red.ref->row->coef_array;
1301 int rlen=red.ref->row->len;
1302 number coef=red.coef;
1303 if (idx_array)
1304 {
1305 if ((coef!=one)&&(coef!=minus_one))
1306 {
1307 write_coef_times_xx_idx_to_buffer(pairs,pos,idx_array, coef_array,rlen, coef);
1308 }
1309 else
1310 {
1311 if (coef==one)
1312 {
1313 write_coef_idx_to_buffer(pairs,pos,idx_array, coef_array,rlen);
1314 }
1315 else
1316 {
1317 assume(coef==minus_one);
1318 write_minus_coef_idx_to_buffer(pairs,pos,idx_array, coef_array,rlen);
1319 }
1320 }
1321 }
1322 else
1323 {
1324 if ((coef!=one)&&(coef!=minus_one))
1325 {
1326 write_coef_times_xx_idx_to_buffer_dense(pairs,pos,coef_array,rlen,coef);
1327 }
1328 else
1329 {
1330 if (coef==one)
1331 write_coef_idx_to_buffer_dense(pairs,pos,coef_array,rlen);
1332 else
1333 {
1334 assume(coef==minus_one);
1335 write_minus_coef_idx_to_buffer_dense(pairs,pos,coef_array,rlen);
1336 }
1337 }
1338 }
1339 }
1340 else
1341 {
1342 if ((red.ref) &&(red.ref->value_len==NoroCache<number_type>::backLinkCode))
1343 {
1346 ci.idx=red.ref->term_index;
1347 pairs[pos++]=ci;
1348 }
1349 }
1350 }
1351 assume(pos<=together);
1352 together=pos;
1353
1354 std::sort(pairs,pairs+together);
1355
1356 int act=0;
1357
1358 assume(pairs[0].coef!=0);
1359 for(i=1;i<together;i++)
1360 {
1361 if (pairs[i].idx!=pairs[act].idx)
1362 {
1363 if (pairs[act].coef!=0)
1364 {
1365 act=act+1;
1366 }
1367 pairs[act]=pairs[i];
1368 }
1369 else
1370 {
1371 pairs[act].coef=F4mat_to_number_type(npAddM((number)(long)pairs[act].coef,(number)(long)pairs[i].coef,currRing->cf));
1372 }
1373 }
1374
1375 if (pairs[act].coef==0)
1376 {
1377 act--;
1378 }
1379 int sparse_row_len=act+1;
1380 //Print("res len:%d",sparse_row_len);
1381 if (sparse_row_len==0) {return NULL;}
1383 {
1384 number_type* coef_array=res->coef_array;
1385 int* idx_array=res->idx_array;
1386 for(i=0;i<sparse_row_len;i++)
1387 {
1388 idx_array[i]=pairs[i].idx;
1389 coef_array[i]=pairs[i].coef;
1390 }
1391 }
1392 //omfree(pairs);
1393
1394 return res;
1395}
number_type coef
void sort(CFArray &A, int l=0)
quick sort A
STATIC_VAR scmon act
Definition: hdegree.cc:1151
void pairs()
void write_minus_coef_idx_to_buffer_dense(CoefIdx< number_type > *const pairs, int &pos, number_type *const coef_array, const int rlen)
void write_minus_coef_idx_to_buffer(CoefIdx< number_type > *const pairs, int &pos, int *const idx_array, number_type *const coef_array, const int rlen)
void write_coef_idx_to_buffer(CoefIdx< number_type > *const pairs, int &pos, int *const idx_array, number_type *const coef_array, const int rlen)
void write_coef_times_xx_idx_to_buffer(CoefIdx< number_type > *const pairs, int &pos, int *const idx_array, number_type *const coef_array, const int rlen, const number coef)
void write_coef_times_xx_idx_to_buffer_dense(CoefIdx< number_type > *const pairs, int &pos, number_type *const coef_array, const int rlen, const number coef)
void write_coef_idx_to_buffer_dense(CoefIdx< number_type > *const pairs, int &pos, number_type *const coef_array, const int rlen)

◆ noro_red_to_non_poly_t()

template<class number_type >
SparseRow< number_type > * noro_red_to_non_poly_t ( poly  p,
int &  len,
NoroCache< number_type > *  cache,
slimgb_alg c 
)

Definition at line 1396 of file tgb_internal.h.

1397{
1398 assume(len==pLength(p));
1399 if (p==NULL)
1400 {
1401 len=0;
1402 return NULL;
1403 }
1404
1406 int i=0;
1407 double max_density=0.0;
1408 while(p!=NULL)
1409 {
1410 poly t=p;
1411 pIter(p);
1412 pNext(t)=NULL;
1413
1415 if ((red.ref) && (red.ref->row))
1416 {
1417 double act_density=(double) red.ref->row->len;
1418 act_density/=(double) cache->nIrreducibleMonomials;
1419 max_density=std::max(act_density,max_density);
1420 }
1421 mon[i]=red;
1422 i++;
1423 }
1424
1425 assume(i==len);
1426 len=i;
1427 bool dense=true;
1428 if (max_density<0.3) dense=false;
1429 if (dense)
1430 {
1432 omfree(mon);
1433 return res;
1434 }
1435 else
1436 {
1438 omfree(mon);
1439 return res;
1440 }
1441 //in the loop before nIrreducibleMonomials increases, so position here is important
1442
1443}
static int max(int a, int b)
Definition: fast_mult.cc:264
#define omfree(addr)
Definition: omAllocDecl.h:237
MonRedResNP< number_type > noro_red_mon_to_non_poly(poly t, NoroCache< number_type > *cache, slimgb_alg *c)
Definition: tgb_internal.h:744
SparseRow< number_type > * noro_red_to_non_poly_dense(MonRedResNP< number_type > *mon, int len, NoroCache< number_type > *cache)
SparseRow< number_type > * noro_red_to_non_poly_sparse(MonRedResNP< number_type > *mon, int len, NoroCache< number_type > *cache)

◆ noro_step()

template<class number_type >
void noro_step ( poly *  p,
int &  pn,
slimgb_alg c 
)

Definition at line 1865 of file tgb_internal.h.

1866{
1867 //Print("Input rows %d\n",pn);
1868 int j;
1869 if (TEST_OPT_PROT)
1870 {
1871 Print("Input rows %d\n",pn);
1872 }
1873
1875
1877 int non_zeros=0;
1878 for(j=0;j<pn;j++)
1879 {
1880 poly h=p[j];
1881 int h_len=pLength(h);
1882 //number coef;
1883 srows[non_zeros]=noro_red_to_non_poly_t<number_type>(h,h_len,&cache,c);
1884 if (srows[non_zeros]!=NULL) non_zeros++;
1885 }
1886 std::vector<DataNoroCacheNode<number_type>*> irr_nodes;
1887 cache.collectIrreducibleMonomials(irr_nodes);
1888 //now can build up terms array
1889 //Print("historic irred Mon%d\n",cache.nIrreducibleMonomials);
1890 int n=irr_nodes.size();//cache.countIrreducibleMonomials();
1891 cache.nIrreducibleMonomials=n;
1892 if (TEST_OPT_PROT)
1893 {
1894 Print("Irred Mon:%d\n",n);
1895 Print("red Mon:%d\n",cache.nReducibleMonomials);
1896 }
1898
1899 for(j=0;j<n;j++)
1900 {
1901 assume(irr_nodes[j]!=NULL);
1902 assume(irr_nodes[j]->value_len==NoroCache<number_type>::backLinkCode);
1903 term_nodes[j].t=irr_nodes[j]->value_poly;
1904 assume(term_nodes[j].t!=NULL);
1905 term_nodes[j].node=irr_nodes[j];
1906 }
1907
1908 qsort(term_nodes,n,sizeof(TermNoroDataNode<number_type>),term_nodes_sort_crit<number_type>);
1909 poly* terms=(poly*) omalloc(n*sizeof(poly));
1910
1911 int* old_to_new_indices=(int*) omalloc(cache.nIrreducibleMonomials*sizeof(int));
1912 for(j=0;j<n;j++)
1913 {
1914 old_to_new_indices[term_nodes[j].node->term_index]=j;
1915 term_nodes[j].node->term_index=j;
1916 terms[j]=term_nodes[j].t;
1917 }
1918
1919 //if (TEST_OPT_PROT)
1920 // Print("Evaluate Rows \n");
1921 pn=non_zeros;
1922 number_type* number_array=(number_type*) omalloc0(((size_t)n)*pn*sizeof(number_type));
1923
1924 for(j=0;j<pn;j++)
1925 {
1926 int i;
1927 number_type* row=number_array+((long)n)*(long)j;
1928 /*for(i=0;i<n;i++)
1929 {
1930 row[i]=zero;
1931 }*/
1932
1933 SparseRow<number_type>* srow=srows[j];
1934
1935 if (srow)
1936 {
1937 int* const idx_array=srow->idx_array;
1938 number_type* const coef_array=srow->coef_array;
1939 const int len=srow->len;
1940 if (srow->idx_array)
1941 {
1942 for(i=0;i<len;i++)
1943 {
1944 int idx=old_to_new_indices[idx_array[i]];
1945 row[idx]=F4mat_to_number_type(coef_array[i]);
1946 }
1947 }
1948 else
1949 {
1950 for(i=0;i<len;i++)
1951 {
1952 row[old_to_new_indices[i]]=F4mat_to_number_type(coef_array[i]);
1953 }
1954 }
1955 delete srow;
1956 }
1957 }
1958
1959 //static int export_n=0;
1960 //export_mat(number_array,pn,n,"mat%i.py",++export_n);
1962
1963 int p_pos=0;
1964 for(j=0;j<pn;j++)
1965 {
1966 poly h=row_to_poly(number_array+((long)j)*((long)n),terms,n,c->r);
1967 if(h!=NULL)
1968 {
1969 p[p_pos++]=h;
1970 }
1971 }
1972 pn=p_pos;
1973 omfree(terms);
1974 omfree(term_nodes);
1976 #ifdef NORO_NON_POLY
1977 omfree(srows);
1978 omfree(old_to_new_indices);
1979 #endif
1980 //don't forget the rank
1981
1982}
void collectIrreducibleMonomials(std::vector< DataNoroCacheNode< number_type > * > &res)
int nReducibleMonomials
Definition: tgb_internal.h:693
#define Print
Definition: emacs.cc:80
number * number_array
Definition: ntupel.cc:25
#define omalloc0(size)
Definition: omAllocDecl.h:229
void simplest_gauss_modp(number_type *a, int nrows, int ncols)
poly row_to_poly(number_type *row, poly *terms, int tn, ring r)
DataNoroCacheNode< number_type > * node
Definition: tgb_internal.h:572

◆ 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}

◆ pELength()

wlen_type pELength ( poly  p,
ring  r 
)

◆ pos_helper()

template<class len_type , class set_type >
int pos_helper ( kStrategy  strat,
poly  p,
len_type  len,
set_type  setL,
polyset  set 
)

Definition at line 383 of file tgb_internal.h.

384{
385 //Print("POSHELER:%d",sizeof(wlen_type));
386 int length=strat->sl;
387 int i;
388 int an = 0;
389 int en= length;
390
391 if ((len>setL[length])
392 || ((len==setL[length]) && (pLmCmp(set[length],p)== -1)))
393 return length+1;
394
395 loop
396 {
397 if (an >= en-1)
398 {
399 if ((len<setL[an])
400 || ((len==setL[an]) && (pLmCmp(set[an],p) == 1))) return an;
401 return en;
402 }
403 i=(an+en) / 2;
404 if ((len<setL[i])
405 || ((len==setL[i]) && (pLmCmp(set[i],p) == 1))) en=i;
406 //else if ((len>setL[i])
407 //|| ((len==setL[i]) && (pLmCmp(set[i],p) == -1))) an=i;
408 else an=i;
409 }
410
411}
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
#define loop
Definition: structs.h:80

◆ 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}

◆ row_to_poly()

template<class number_type >
poly row_to_poly ( number_type *  row,
poly *  terms,
int  tn,
ring  r 
)

Definition at line 1468 of file tgb_internal.h.

1469{
1470 poly h=NULL;
1471 int j;
1472 number_type zero=0;//;npInit(0);
1473 for(j=tn-1;j>=0;j--)
1474 {
1475 if (!(zero==(row[j])))
1476 {
1477 poly t=terms[j];
1478 t=p_LmInit(t,r);
1479 p_SetCoeff(t,(number)(long) row[j],r);
1480 pNext(t)=h;
1481 h=t;
1482 }
1483
1484 }
1485 return h;
1486}
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1295

◆ simplest_gauss_modp()

template<class number_type >
void simplest_gauss_modp ( number_type *  a,
int  nrows,
int  ncols 
)

Definition at line 1842 of file tgb_internal.h.

1843{
1844 //use memmoves for changing rows
1845 //if (TEST_OPT_PROT)
1846 // PrintS("StartGauss\n");
1848
1849 int c=0;
1850 int r=0;
1851 while(mat.findPivot(r,c))
1852 {
1853 //int pivot=find_pivot()
1854 mat.reduceOtherRowsForward(r);
1855 r++;
1856 c++;
1857 }
1859 backmat.backwardSubstitute();
1860 //backward substitutions
1861 //if (TEST_OPT_PROT)
1862 //PrintS("StopGauss\n");
1863}
int nrows
Definition: cf_linsys.cc:32

◆ 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 FORCE_INLINE int nlQlogSize(number n, const coeffs r)
only used by slimgb (tgb.cc)
Definition: longrat.h:76
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:502
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:508

◆ 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
#define omrealloc(addr, size)
Definition: omAllocDecl.h:233
static int posInPairs(sorted_pair_node **p, int pn, sorted_pair_node *qe, slimgb_alg *c, int an=0)
Definition: tgb.cc:711

◆ sub_dense()

template<class number_type >
void sub_dense ( number_type *const  temp_array,
int  ,
const number_type *  row,
int  len 
)

Definition at line 1013 of file tgb_internal.h.

1019{
1020 //int j;
1021 //const number_type* const coef_array=row;
1022 //int* const idx_array=row->idx_array;
1023 //const int len=temp_size;
1024 //tgb_uint32 buffer[256];
1025 //const tgb_uint32 prime=npPrimeM;
1026 //const tgb_uint32 c=F4mat_to_number_type(coef);
1027
1028 int i;
1029 for(i=0;i<len;i++)
1030 {
1031 temp_array[i]=F4mat_to_number_type(npSubM((number)(long) temp_array[i], (number)(long) row[i],currRing->cf));
1032 #ifndef SING_NDEBUG
1033 assume(i<temp_size);
1034 #endif
1035 }
1036}
static number npSubM(number a, number b, const coeffs r)
Definition: modulop.h:126

◆ sub_sparse()

template<class number_type >
void sub_sparse ( number_type *const  temp_array,
int  ,
SparseRow< number_type > *  row 
)

Definition at line 1059 of file tgb_internal.h.

1063{
1064 int j;
1065
1066 number_type* const coef_array=row->coef_array;
1067 int* const idx_array=row->idx_array;
1068 const int len=row->len;
1069 for(j=0;j<len;j++)
1070 {
1071 int idx=idx_array[j];
1072 temp_array[idx]=F4mat_to_number_type( (number_type)(long) npSubM((number) (long)temp_array[idx],(number)(long) coef_array[j],currRing->cf));
1073 #ifndef SING_NDEBUG
1074 assume(idx<temp_size);
1075 #endif
1076 }
1077}

◆ term_nodes_sort_crit()

template<class number_type >
int term_nodes_sort_crit ( const void *  a,
const void *  b 
)

Definition at line 1500 of file tgb_internal.h.

1501{
1503}
CanonicalForm b
Definition: cfModGcd.cc:4105

◆ 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_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}
Definition: ap.h:40
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

◆ write_coef_idx_to_buffer()

template<class number_type >
void write_coef_idx_to_buffer ( CoefIdx< number_type > *const  pairs,
int &  pos,
int *const  idx_array,
number_type *const  coef_array,
const int  rlen 
)

Definition at line 1243 of file tgb_internal.h.

1244{
1245 int j;
1246 for(j=0;j<rlen;j++)
1247 {
1248 assume(coef_array[j]!=0);
1250 ci.coef=coef_array[j];
1251 ci.idx=idx_array[j];
1252 pairs[pos++]=ci;
1253 }
1254}

◆ write_coef_idx_to_buffer_dense()

template<class number_type >
void write_coef_idx_to_buffer_dense ( CoefIdx< number_type > *const  pairs,
int &  pos,
number_type *const  coef_array,
const int  rlen 
)

Definition at line 1208 of file tgb_internal.h.

1209{
1210 int j;
1211
1212 for(j=0;j<rlen;j++)
1213 {
1214 if (coef_array[j]!=0)
1215 {
1216 assume(coef_array[j]!=0);
1218 ci.coef=coef_array[j];
1219 assume(ci.coef!=0);
1220 ci.idx=j;
1221 pairs[pos++]=ci;
1222 }
1223 }
1224}

◆ write_coef_times_xx_idx_to_buffer()

template<class number_type >
void write_coef_times_xx_idx_to_buffer ( CoefIdx< number_type > *const  pairs,
int &  pos,
int *const  idx_array,
number_type *const  coef_array,
const int  rlen,
const number  coef 
)

Definition at line 1179 of file tgb_internal.h.

1180{
1181 int j;
1182 for(j=0;j<rlen;j++)
1183 {
1184 assume(coef_array[j]!=0);
1186 ci.coef=F4mat_to_number_type(npMultM((number)(long) coef,(number)(long) coef_array[j],currRing->cf));
1187 ci.idx=idx_array[j];
1188 pairs[pos++]=ci;
1189 }
1190}
static number npMultM(number a, number b, const coeffs r)
Definition: modulop.h:63

◆ write_coef_times_xx_idx_to_buffer_dense()

template<class number_type >
void write_coef_times_xx_idx_to_buffer_dense ( CoefIdx< number_type > *const  pairs,
int &  pos,
number_type *const  coef_array,
const int  rlen,
const number  coef 
)

Definition at line 1191 of file tgb_internal.h.

1192{
1193 int j;
1194
1195 for(j=0;j<rlen;j++)
1196 {
1197 if (coef_array[j]!=0)
1198 {
1199 assume(coef_array[j]!=0);
1201 ci.coef=F4mat_to_number_type(npMultM((number)(long) coef,(number)(long) coef_array[j],currRing->cf));
1202 assume(ci.coef!=0);
1203 ci.idx=j;
1204 pairs[pos++]=ci;
1205 }
1206 }
1207}

◆ write_minus_coef_idx_to_buffer()

template<class number_type >
void write_minus_coef_idx_to_buffer ( CoefIdx< number_type > *const  pairs,
int &  pos,
int *const  idx_array,
number_type *const  coef_array,
const int  rlen 
)

Definition at line 1256 of file tgb_internal.h.

1257{
1258 int j;
1259 for(j=0;j<rlen;j++)
1260 {
1261 assume(coef_array[j]!=0);
1263 ci.coef=F4mat_to_number_type(npNegM((number)(unsigned long)coef_array[j],currRing->cf)); // FIXME: inplace negation! // TODO: check if this is not a bug!?
1264 ci.idx=idx_array[j];
1265 pairs[pos++]=ci;
1266 }
1267}

◆ write_minus_coef_idx_to_buffer_dense()

template<class number_type >
void write_minus_coef_idx_to_buffer_dense ( CoefIdx< number_type > *const  pairs,
int &  pos,
number_type *const  coef_array,
const int  rlen 
)

Definition at line 1226 of file tgb_internal.h.

1227{
1228 int j;
1229
1230 for(j=0;j<rlen;j++)
1231 {
1232 if (coef_array[j]!=0)
1233 {
1234 assume(coef_array[j]!=0);
1236 ci.coef=F4mat_to_number_type(npNegM((number)(long) coef_array[j],currRing->cf)); // FIXME: inplace negation! // TODO: check if this is not a bug!?
1237 assume(ci.coef!=0);
1238 ci.idx=j;
1239 pairs[pos++]=ci;
1240 }
1241 }
1242}

◆ write_poly_to_row()

template<class number_type >
void write_poly_to_row ( number_type *  row,
poly  h,
poly *  terms,
int  tn,
ring  r 
)

Definition at line 1453 of file tgb_internal.h.

1454{
1455 //poly* base=row;
1456 while(h!=NULL)
1457 {
1458 //Print("h:%i\n",h);
1459 number coef=p_GetCoeff(h,r);
1460 poly* ptr_to_h=(poly*) bsearch(&h,terms,tn,sizeof(poly),terms_sort_crit);
1461 assume(ptr_to_h!=NULL);
1462 int pos=ptr_to_h-terms;
1463 row[pos]=F4mat_to_number_type(coef);
1464 //number_type_array[base+pos]=coef;
1465 pIter(h);
1466 }
1467}
int terms_sort_crit(const void *a, const void *b)
Definition: tgb.cc:2030