My Project
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 long * initsevT ()
 
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 1272 of file kInline.h.

1273 {
1274  return FALSE;
1275 }
#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 1247 of file kInline.h.

1249 {
1250  assume(p_sev == pGetShortExpVector(p));
1251  if (strat->noClearS) return;
1252  #ifdef HAVE_RINGS
1254  {
1255  if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at]))
1256  return;
1257  if(!n_DivBy(pGetCoeff(strat->S[*at]), pGetCoeff(p), currRing->cf))
1258  return;
1259  }
1260  else
1261  #endif
1262  {
1263  if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
1264  }
1265  deleteInS((*at),strat);
1266  (*at)--;
1267  (*k)--;
1268 }
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:753
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:1163
#define assume(x)
Definition: mod2.h:387
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:486

◆ 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)
Definition: omAllocDecl.h:211

◆ 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 1028 of file kInline.h.

1030 {
1031  p_LmCheckPolyRing(p1, p_r);
1032  p_LmCheckPolyRing(p2, p_r);
1033 
1034  int i;
1035  long x;
1036  m1 = p_Init(m_r,m_r->PolyBin);
1037  m2 = p_Init(m_r,m_r->PolyBin);
1038 
1039  for (i = p_r->N; i; i--)
1040  {
1041  x = p_GetExpDiff(p1, p2, i, p_r);
1042  if (x > 0)
1043  {
1044  if (x > (long) m_r->bitmask) goto false_return;
1045  p_SetExp(m2,i,x, m_r);
1046  p_SetExp(m1,i,0, m_r);
1047  }
1048  else
1049  {
1050  if (-x > (long) m_r->bitmask) goto false_return;
1051  p_SetExp(m1,i,-x, m_r);
1052  p_SetExp(m2,i,0, m_r);
1053  }
1054  }
1055 
1056  p_Setm(m1, m_r);
1057  p_Setm(m2, m_r);
1058  return TRUE;
1059 
1060  false_return:
1061  p_LmFree(m1, m_r);
1062  p_LmFree(m2, m_r);
1063  m1 = m2 = NULL;
1064  return FALSE;
1065 }
#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:120
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:1292

◆ 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 1071 of file kInline.h.

1073 {
1074  p_LmCheckPolyRing(p1, leadRing);
1075  p_LmCheckPolyRing(p2, leadRing);
1076 
1077  int i;
1078  int x;
1079  int e1;
1080  int e2;
1081  int s;
1082  m1 = p_Init(tailRing,tailRing->PolyBin);
1083  m2 = p_Init(tailRing,tailRing->PolyBin);
1084  lcm = p_Init(leadRing,leadRing->PolyBin);
1085 
1086  for (i = leadRing->N; i>=0; i--)
1087  {
1088  e1 = p_GetExp(p1,i,leadRing);
1089  e2 = p_GetExp(p2,i,leadRing);
1090  x = e1 - e2;
1091  if (x > 0)
1092  {
1093  p_SetExp(m2,i,x, tailRing);
1094  //p_SetExp(m1,i,0, tailRing); // done by p_Init
1095  s = e1;
1096  }
1097  else if (x<0)
1098  {
1099  p_SetExp(m1,i,-x, tailRing);
1100  //p_SetExp(m2,i,0, tailRing); // done by p_Init
1101  s = e2;
1102  }
1103  else
1104  s = e1; // e1==e2
1105  p_SetExp(lcm,i,s, leadRing);
1106  }
1107 
1108  p_Setm(m1, tailRing);
1109  p_Setm(m2, tailRing);
1110  p_Setm(lcm, leadRing);
1111 }
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 1001 of file kInline.h.

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

◆ k_LmInit_currRing_2_tailRing() [2/2]

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

Definition at line 969 of file kInline.h.

970 {
971 
972  poly t_p = p_LmInit(p, currRing, tailRing, tailBin);
973  pNext(t_p) = pNext(p);
974  pSetCoeff0(t_p, pGetCoeff(p));
975  return t_p;
976 }
#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:1307

◆ k_LmInit_tailRing_2_currRing() [1/2]

KINLINE poly k_LmInit_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 1006 of file kInline.h.

1007 {
1008  return k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
1009 }
KINLINE poly k_LmInit_tailRing_2_currRing(poly t_p, ring tailRing, omBin lmBin)
Definition: kInline.h:978

◆ k_LmInit_tailRing_2_currRing() [2/2]

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

Definition at line 978 of file kInline.h.

979 {
980  poly p = p_LmInit(t_p, tailRing, currRing, lmBin);
981  pNext(p) = pNext(t_p);
982  pSetCoeff0(p, pGetCoeff(t_p));
983  return p;
984 }

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing ( poly  p,
ring  tailRing 
)

Definition at line 1011 of file kInline.h.

1012 {
1013  return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
1014 }
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition: kInline.h:987

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [2/2]

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

Definition at line 987 of file kInline.h.

988 {
989  poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
990  p_LmFree(p, currRing);
991  return np;
992 }

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 1016 of file kInline.h.

1017 {
1018  return k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
1019 }
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
Definition: kInline.h:994

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [2/2]

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

Definition at line 994 of file kInline.h.

995 {
996  poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
997  p_LmFree(p, tailRing);
998  return np;
999 }

◆ ksOldCreateSpoly()

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

Definition at line 1204 of file kInline.h.

1205 {
1206  LObject L(r);
1207  L.p1 = p1;
1208  L.p2 = p2;
1209 
1210  ksCreateSpoly(&L, spNoether);
1211  return L.GetLmCurrRing();
1212 }
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition: kspoly.cc:1185
class sLObject LObject
Definition: kutil.h:58

◆ ksOldSpolyRed()

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

Definition at line 1184 of file kInline.h.

1185 {
1186  LObject L(p2);
1187  TObject T(p1);
1188 
1189  ksReducePoly(&L, &T, spNoether);
1190 
1191  return L.GetLmCurrRing();
1192 }
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat)
Definition: kspoly.cc:187

◆ ksOldSpolyRedNew()

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

Definition at line 1194 of file kInline.h.

1195 {
1196  LObject L(p_Copy(p2, currRing));
1197  TObject T(p1);
1198 
1199  ksReducePoly(&L, &T, spNoether);
1200 
1201  return L.GetLmCurrRing();
1202 }
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:818

◆ ksOldSpolyTail()

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

Definition at line 1214 of file kInline.h.

1215 {
1216  LObject L(q, currRing, r);
1217  TObject T(p1, currRing, r);
1218 
1219  ksReducePolyTail(&L, &T, q2, spNoether);
1220 }
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1157

◆ ksReducePolyTail()

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

Definition at line 1157 of file kInline.h.

1158 {
1159  BOOLEAN ret;
1160  number coef;
1161 
1162  assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1163  Red->HeadNormalize();
1164  ret = ksReducePoly(Red, PW, NULL, &coef);
1165 
1166  if (!ret)
1167  {
1168  if (! n_IsOne(coef, currRing->cf))
1169  {
1170  PR->Mult_nn(coef);
1171  // HANNES: mark for Normalize
1172  }
1173  n_Delete(&coef, currRing->cf);
1174  }
1175  return ret;
1176 }
int BOOLEAN
Definition: auxiliary.h:87
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468

◆ ksReducePolyTail_Z()

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

Definition at line 1137 of file kInline.h.

1138 {
1139  BOOLEAN ret;
1140  number coef;
1141 
1142  assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1143  ret = ksReducePoly(Red, PW, NULL, &coef);
1144 
1145  if (!ret)
1146  {
1147  if (! n_IsOne(coef, currRing->cf))
1148  {
1149  PR->Mult_nn(coef);
1150  // HANNES: mark for Normalize
1151  }
1152  n_Delete(&coef, currRing->cf);
1153  }
1154  return ret;
1155 }

◆ ksReducePolyTailLC_Z()

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

Definition at line 1119 of file kInline.h.

1120 {
1121  BOOLEAN ret;
1122  number mult, rest;
1123  TObject red = *PW;
1124  red.Copy();
1125  rest = n_QuotRem(pGetCoeff(Red->p), pGetCoeff(red.p),
1126  &mult, currRing->cf);
1127  red.Mult_nn(rest);
1128 
1129  assume(PR->GetLmCurrRing() != red.GetLmCurrRing());
1130  ret = ksReducePolyLC(Red, &red, NULL, &mult);
1131  red.Delete();
1132  red.Clear();
1133 
1134  return ret;
1135 }
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:681
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition: kspoly.cc:458
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 1222 of file kInline.h.

1223 {
1224  LObject L(p);
1225  return redtailBba(&L, pos, strat,FALSE, normalize);
1226 }
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition: kInline.h:1222
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1026

◆ redtailBba_Ring()

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

Definition at line 1235 of file kInline.h.

1236 {
1237  LObject L(p, currRing, strat->tailRing);
1238  return redtailBba_Ring(&L, pos, strat);
1239 }
ring tailRing
Definition: kutil.h:343
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
Definition: kInline.h:1235

◆ redtailBba_Z()

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

Definition at line 1240 of file kInline.h.

1241 {
1242  LObject L(p, currRing, strat->tailRing);
1243  return redtailBba_Z(&L, pos, strat);
1244 }
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition: kInline.h:1240

◆ redtailBbaBound()

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

Definition at line 1228 of file kInline.h.

1229 {
1230  LObject L(p, currRing, strat->tailRing); // ? L(p); ??
1231  return redtailBbaBound(&L, pos, strat,bound, FALSE, normalize);
1232 }
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:1228