My Project
Loading...
Searching...
No Matches
Macros | Functions
kInline.h File Reference
#include "omalloc/omalloc.h"
#include "misc/options.h"
#include "polys/monomials/p_polys.h"
#include "polys/kbuckets.h"
#include "kernel/polys.h"
#include "polys/shiftop.h"

Go to the source code of this file.

Macros

#define HAVE_TAIL_BIN
 

Functions

KINLINE TSet initT ()
 
KINLINE TObject ** initR ()
 
KINLINE unsigned longinitsevT ()
 
KINLINE poly k_LmInit_currRing_2_tailRing (poly p, ring tailRing, omBin tailBin)
 
KINLINE poly k_LmInit_tailRing_2_currRing (poly t_p, ring tailRing, omBin lmBin)
 
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing, omBin tailBin)
 
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing, omBin lmBin)
 
KINLINE poly k_LmInit_currRing_2_tailRing (poly p, ring tailRing)
 
KINLINE poly k_LmInit_tailRing_2_currRing (poly p, ring tailRing)
 
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing)
 
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing)
 
KINLINE BOOLEAN k_GetLeadTerms (const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
 
KINLINE void k_GetStrongLeadTerms (const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
 
KINLINE int ksReducePolyTailLC_Z (LObject *PR, TObject *PW, LObject *Red)
 
KINLINE int ksReducePolyTail_Z (LObject *PR, TObject *PW, LObject *Red)
 
KINLINE int ksReducePolyTail (LObject *PR, TObject *PW, LObject *Red)
 
KINLINE poly ksOldSpolyRed (poly p1, poly p2, poly spNoether)
 
KINLINE poly ksOldSpolyRedNew (poly p1, poly p2, poly spNoether)
 
KINLINE poly ksOldCreateSpoly (poly p1, poly p2, poly spNoether, ring r)
 
void ksOldSpolyTail (poly p1, poly q, poly q2, poly spNoether, ring r)
 
KINLINE poly redtailBba (poly p, int pos, kStrategy strat, BOOLEAN normalize)
 
KINLINE poly redtailBbaBound (poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
 
KINLINE poly redtailBba_Ring (poly p, int pos, kStrategy strat)
 
KINLINE poly redtailBba_Z (poly p, int pos, kStrategy strat)
 
KINLINE void clearS (poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
 
KINLINE BOOLEAN arriRewDummy (poly, unsigned long, poly, kStrategy, int)
 

Macro Definition Documentation

◆ HAVE_TAIL_BIN

#define HAVE_TAIL_BIN

Definition at line 32 of file kInline.h.

Function Documentation

◆ arriRewDummy()

KINLINE BOOLEAN arriRewDummy ( poly  sig,
unsigned long  not_sevSig,
poly  lm,
kStrategy  strat,
int  start 
)

Definition at line 1263 of file kInline.h.

1264{
1265 return FALSE;
1266}
#define FALSE
Definition auxiliary.h:96

◆ clearS()

KINLINE void clearS ( poly  p,
unsigned long  p_sev,
int at,
int k,
kStrategy  strat 
)

Definition at line 1238 of file kInline.h.

1240{
1242 if (strat->noClearS) return;
1243 #ifdef HAVE_RINGS
1245 {
1246 if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at]))
1247 return;
1248 if(!n_DivBy(pGetCoeff(strat->S[*at]), pGetCoeff(p), currRing->cf))
1249 return;
1250 }
1251 else
1252 #endif
1253 {
1254 if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
1255 }
1256 deleteInS((*at),strat);
1257 (*at)--;
1258 (*k)--;
1259}
int p
Definition cfModGcd.cc:4078
polyset S
Definition kutil.h:306
char noClearS
Definition kutil.h:402
unsigned long * sevS
Definition kutil.h:322
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition coeffs.h:750
void deleteInS(int i, kStrategy strat)
Definition kutil.cc:1138
#define assume(x)
Definition mod2.h:389
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
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
#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 rField_is_Ring(R)
Definition ring.h:485

◆ initR()

KINLINE TObject ** initR ( )

Definition at line 95 of file kInline.h.

96{
97 return (TObject**) omAlloc0(setmaxT*sizeof(TObject*));
98}
#define setmaxT
Definition kutil.h:33
class sTObject TObject
Definition kutil.h:57
#define omAlloc0(size)

◆ initsevT()

KINLINE unsigned long * initsevT ( )

Definition at line 100 of file kInline.h.

101{
102 return (unsigned long*) omAlloc0(setmaxT*sizeof(unsigned long));
103}

◆ initT()

KINLINE TSet initT ( )

Definition at line 84 of file kInline.h.

85{
86 TSet T = (TSet)omAlloc0(setmaxT*sizeof(TObject));
87 for (int i=setmaxT-1; i>=0; i--)
88 {
89 T[i].tailRing = currRing;
90 T[i].i_r = -1;
91 }
92 return T;
93}
int i
Definition cfEzgcd.cc:132
STATIC_VAR jList * T
Definition janet.cc:30
TObject * TSet
Definition kutil.h:59

◆ k_GetLeadTerms()

KINLINE BOOLEAN k_GetLeadTerms ( const poly  p1,
const poly  p2,
const ring  p_r,
poly &  m1,
poly &  m2,
const ring  m_r 
)

Definition at line 1017 of file kInline.h.

1019{
1022
1023 int i;
1024 long x;
1025 m1 = p_Init(m_r,m_r->PolyBin);
1026 m2 = p_Init(m_r,m_r->PolyBin);
1027
1028 for (i = p_r->N; i; i--)
1029 {
1030 x = p_GetExpDiff(p1, p2, i, p_r);
1031 if (x > 0)
1032 {
1033 if (x > (long) m_r->bitmask) goto false_return;
1034 p_SetExp(m2,i,x, m_r);
1035 p_SetExp(m1,i,0, m_r);
1036 }
1037 else
1038 {
1039 if (-x > (long) m_r->bitmask) goto false_return;
1040 p_SetExp(m1,i,-x, m_r);
1041 p_SetExp(m2,i,0, m_r);
1042 }
1043 }
1044
1045 p_Setm(m1, m_r);
1046 p_Setm(m2, m_r);
1047 return TRUE;
1048
1050 p_LmFree(m1, m_r);
1051 p_LmFree(m2, m_r);
1052 m1 = m2 = NULL;
1053 return FALSE;
1054}
#define TRUE
Definition auxiliary.h:100
Variable x
Definition cfModGcd.cc:4082
#define NULL
Definition omList.c:12
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition p_polys.h:635
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
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 void p_Setm(poly p, const ring r)
Definition p_polys.h:233
static void p_LmFree(poly p, ring)
Definition p_polys.h:683
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1320

◆ k_GetStrongLeadTerms()

KINLINE void k_GetStrongLeadTerms ( const poly  p1,
const poly  p2,
const ring  leadRing,
poly &  m1,
poly &  m2,
poly &  lcm,
const ring  tailRing 
)

Definition at line 1060 of file kInline.h.

1062{
1065
1066 int i;
1067 int x;
1068 int e1;
1069 int e2;
1070 int s;
1071 m1 = p_Init(tailRing,tailRing->PolyBin);
1072 m2 = p_Init(tailRing,tailRing->PolyBin);
1073 lcm = p_Init(leadRing,leadRing->PolyBin);
1074
1075 for (i = leadRing->N; i>=0; i--)
1076 {
1077 e1 = p_GetExp(p1,i,leadRing);
1078 e2 = p_GetExp(p2,i,leadRing);
1079 x = e1 - e2;
1080 if (x > 0)
1081 {
1082 p_SetExp(m2,i,x, tailRing);
1083 //p_SetExp(m1,i,0, tailRing); // done by p_Init
1084 s = e1;
1085 }
1086 else if (x<0)
1087 {
1088 p_SetExp(m1,i,-x, tailRing);
1089 //p_SetExp(m2,i,0, tailRing); // done by p_Init
1090 s = e2;
1091 }
1092 else
1093 s = e1; // e1==e2
1095 }
1096
1097 p_Setm(m1, tailRing);
1098 p_Setm(m2, tailRing);
1100}
const CanonicalForm int s
Definition facAbsFact.cc:51
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition minpoly.cc:709
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

◆ k_LmInit_currRing_2_tailRing() [1/2]

KINLINE poly k_LmInit_currRing_2_tailRing ( poly  p,
ring  tailRing 
)

Definition at line 990 of file kInline.h.

991{
992 return k_LmInit_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
993}
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition kInline.h:958

◆ k_LmInit_currRing_2_tailRing() [2/2]

KINLINE poly k_LmInit_currRing_2_tailRing ( poly  p,
ring  tailRing,
omBin  tailBin 
)

Definition at line 958 of file kInline.h.

959{
960
961 poly t_p = p_LmInit(p, currRing, tailRing, tailBin);
962 pNext(t_p) = pNext(p);
963 pSetCoeff0(t_p, pGetCoeff(p));
964 return t_p;
965}
#define pNext(p)
Definition monomials.h:36
#define pSetCoeff0(p, n)
Definition monomials.h:59
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1335

◆ k_LmInit_tailRing_2_currRing() [1/2]

KINLINE poly k_LmInit_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 995 of file kInline.h.

996{
997 return k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
998}
KINLINE poly k_LmInit_tailRing_2_currRing(poly t_p, ring tailRing, omBin lmBin)
Definition kInline.h:967

◆ k_LmInit_tailRing_2_currRing() [2/2]

KINLINE poly k_LmInit_tailRing_2_currRing ( poly  t_p,
ring  tailRing,
omBin  lmBin 
)

Definition at line 967 of file kInline.h.

968{
969 poly p = p_LmInit(t_p, tailRing, currRing, lmBin);
970 pNext(p) = pNext(t_p);
971 pSetCoeff0(p, pGetCoeff(t_p));
972 return p;
973}

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing ( poly  p,
ring  tailRing 
)

Definition at line 1000 of file kInline.h.

1001{
1002 return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
1003}
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition kInline.h:976

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [2/2]

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing ( poly  p,
ring  tailRing,
omBin  tailBin 
)

Definition at line 976 of file kInline.h.

977{
978 poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
980 return np;
981}

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 1005 of file kInline.h.

1006{
1007 return k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
1008}
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
Definition kInline.h:983

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [2/2]

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing ( poly  p,
ring  tailRing,
omBin  lmBin 
)

Definition at line 983 of file kInline.h.

984{
985 poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
986 p_LmFree(p, tailRing);
987 return np;
988}

◆ ksOldCreateSpoly()

KINLINE poly ksOldCreateSpoly ( poly  p1,
poly  p2,
poly  spNoether,
ring  r 
)

Definition at line 1195 of file kInline.h.

1196{
1197 LObject L(r);
1198 L.p1 = p1;
1199 L.p2 = p2;
1200
1202 return L.GetLmCurrRing();
1203}
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition kspoly.cc:1208
class sLObject LObject
Definition kutil.h:58

◆ ksOldSpolyRed()

KINLINE poly ksOldSpolyRed ( poly  p1,
poly  p2,
poly  spNoether 
)

Definition at line 1175 of file kInline.h.

1176{
1177 LObject L(p2);
1178 TObject T(p1);
1179
1180 ksReducePoly(&L, &T, spNoether);
1181
1182 return L.GetLmCurrRing();
1183}
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat, BOOLEAN reduce)
Definition kspoly.cc:189

◆ ksOldSpolyRedNew()

KINLINE poly ksOldSpolyRedNew ( poly  p1,
poly  p2,
poly  spNoether 
)

Definition at line 1185 of file kInline.h.

1186{
1187 LObject L(p_Copy(p2, currRing));
1188 TObject T(p1);
1189
1190 ksReducePoly(&L, &T, spNoether);
1191
1192 return L.GetLmCurrRing();
1193}
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:846

◆ ksOldSpolyTail()

void ksOldSpolyTail ( poly  p1,
poly  q,
poly  q2,
poly  spNoether,
ring  r 
)

Definition at line 1205 of file kInline.h.

1206{
1207 LObject L(q, currRing, r);
1208 TObject T(p1, currRing, r);
1209
1211}
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
Definition kInline.h:1148

◆ ksReducePolyTail()

KINLINE int ksReducePolyTail ( LObject PR,
TObject PW,
LObject Red 
)

Definition at line 1148 of file kInline.h.

1149{
1150 BOOLEAN ret;
1151 number coef;
1152
1153 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1154 Red->HeadNormalize();
1155 ret = ksReducePoly(Red, PW, NULL, &coef);
1156
1157 if (!ret)
1158 {
1159 if (! n_IsOne(coef, currRing->cf))
1160 {
1161 PR->Mult_nn(coef);
1162 // HANNES: mark for Normalize
1163 }
1164 n_Delete(&coef, currRing->cf);
1165 }
1166 return ret;
1167}
int BOOLEAN
Definition auxiliary.h:87
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:452
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:465

◆ ksReducePolyTail_Z()

KINLINE int ksReducePolyTail_Z ( LObject PR,
TObject PW,
LObject Red 
)

Definition at line 1126 of file kInline.h.

1127{
1128 BOOLEAN ret;
1129 number coef=NULL;
1130
1131 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1132 ret = ksReducePoly(Red, PW, NULL, &coef, NULL,NULL,TRUE);
1133
1134#if 0 // shlould not happen
1135 if (!ret)
1136 {
1137 if (! n_IsOne(coef, currRing->cf))
1138 {
1139 PR->Mult_nn(coef);
1140 // HANNES: mark for Normalize
1141 }
1142 }
1143#endif
1144 n_Delete(&coef, currRing->cf);
1145 return ret;
1146}

◆ ksReducePolyTailLC_Z()

KINLINE int ksReducePolyTailLC_Z ( LObject PR,
TObject PW,
LObject Red 
)

Definition at line 1108 of file kInline.h.

1109{
1110 BOOLEAN ret;
1111 number mult, rest;
1112 TObject red = *PW;
1113 red.Copy();
1114 rest = n_QuotRem(pGetCoeff(Red->p), pGetCoeff(red.p),
1115 &mult, currRing->cf);
1116 red.Mult_nn(rest);
1117
1118 assume(PR->GetLmCurrRing() != red.GetLmCurrRing());
1119 ret = ksReducePolyLC(Red, &red, NULL, &mult);
1120 red.Delete();
1121 red.Clear();
1122
1123 return ret;
1124}
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition coeffs.h:678
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition kspoly.cc:481
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition minpoly.cc:647

◆ redtailBba()

KINLINE poly redtailBba ( poly  p,
int  pos,
kStrategy  strat,
BOOLEAN  normalize 
)

Definition at line 1213 of file kInline.h.

1214{
1215 LObject L(p);
1216 return redtailBba(&L, pos, strat,FALSE, normalize);
1217}
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition kInline.h:1213
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition syz3.cc:1027

◆ redtailBba_Ring()

KINLINE poly redtailBba_Ring ( poly  p,
int  pos,
kStrategy  strat 
)

Definition at line 1226 of file kInline.h.

1227{
1228 LObject L(p, currRing, strat->tailRing);
1229 return redtailBba_Ring(&L, pos, strat);
1230}
ring tailRing
Definition kutil.h:343
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
Definition kInline.h:1226

◆ redtailBba_Z()

KINLINE poly redtailBba_Z ( poly  p,
int  pos,
kStrategy  strat 
)

Definition at line 1231 of file kInline.h.

1232{
1233 LObject L(p, currRing, strat->tailRing);
1234 return redtailBba_Z(&L, pos, strat);
1235}
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition kInline.h:1231

◆ redtailBbaBound()

KINLINE poly redtailBbaBound ( poly  p,
int  pos,
kStrategy  strat,
int  bound,
BOOLEAN  normalize 
)

Definition at line 1219 of file kInline.h.

1220{
1221 LObject L(p, currRing, strat->tailRing); // ? L(p); ??
1222 return redtailBbaBound(&L, pos, strat,bound, FALSE, normalize);
1223}
static CanonicalForm bound(const CFMatrix &M)
Definition cf_linsys.cc:460
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
Definition kInline.h:1219