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

{
  return FALSE;
}

clearS()

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

Definition at line 1248 of file kInline.h.

{
  assume(p_sev == pGetShortExpVector(p));
  if (strat->noClearS) return;
  #ifdef HAVE_RINGS
  if(rField_is_Ring(currRing))
  {
    if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at]))
      return;
    if(!n_DivBy(pGetCoeff(strat->S[*at]), pGetCoeff(p), currRing->cf))
      return;
  }
  else
  #endif
  {
    if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
  }
  deleteInS((*at),strat);
  (*at)--;
  (*k)--;
}

initR()

KINLINE TObject ** initR

(

)

Definition at line 95 of file kInline.h.

{
  return (TObject**) omAlloc0(setmaxT*sizeof(TObject*));
}

initsevT()

KINLINE unsigned long * initsevT

(

)

Definition at line 100 of file kInline.h.

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

initT()

KINLINE TSet initT

(

)

Definition at line 84 of file kInline.h.

{
  TSet T = (TSet)omAlloc0(setmaxT*sizeof(TObject));
  for (int i=setmaxT-1; i>=0; i--)
  {
    T[i].tailRing = currRing;
    T[i].i_r = -1;
  }
  return T;
}

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

{
  p_LmCheckPolyRing(p1, p_r);
  p_LmCheckPolyRing(p2, p_r);
 
  int i;
  long x;
  m1 = p_Init(m_r,m_r->PolyBin);
  m2 = p_Init(m_r,m_r->PolyBin);
 
  for (i = p_r->N; i; i--)
  {
    x = p_GetExpDiff(p1, p2, i, p_r);
    if (x > 0)
    {
      if (x > (long) m_r->bitmask) goto false_return;
      p_SetExp(m2,i,x, m_r);
      p_SetExp(m1,i,0, m_r);
    }
    else
    {
      if (-x > (long) m_r->bitmask) goto false_return;
      p_SetExp(m1,i,-x, m_r);
      p_SetExp(m2,i,0, m_r);
    }
  }
 
  p_Setm(m1, m_r);
  p_Setm(m2, m_r);
  return TRUE;
 
  false_return:
  p_LmFree(m1, m_r);
  p_LmFree(m2, m_r);
  m1 = m2 = NULL;
  return FALSE;
}

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

{
  p_LmCheckPolyRing(p1, leadRing);
  p_LmCheckPolyRing(p2, leadRing);
 
  int i;
  int x;
  int e1;
  int e2;
  int s;
  m1 = p_Init(tailRing,tailRing->PolyBin);
  m2 = p_Init(tailRing,tailRing->PolyBin);
  lcm = p_Init(leadRing,leadRing->PolyBin);
 
  for (i = leadRing->N; i>=0; i--)
  {
    e1 = p_GetExp(p1,i,leadRing);
    e2 = p_GetExp(p2,i,leadRing);
    x = e1 - e2;
    if (x > 0)
    {
      p_SetExp(m2,i,x, tailRing);
      //p_SetExp(m1,i,0, tailRing); // done by p_Init
      s = e1;
    }
    else if (x<0)
    {
      p_SetExp(m1,i,-x, tailRing);
      //p_SetExp(m2,i,0, tailRing); // done by p_Init
      s = e2;
    }
    else
      s = e1; // e1==e2
    p_SetExp(lcm,i,s, leadRing);
  }
 
  p_Setm(m1, tailRing);
  p_Setm(m2, tailRing);
  p_Setm(lcm, leadRing);
}

k_LmInit_currRing_2_tailRing() [1/2]

KINLINE poly k_LmInit_currRing_2_tailRing	(	poly	p,
		ring	tailRing
	)

Definition at line 1002 of file kInline.h.

{
  return k_LmInit_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
}

k_LmInit_currRing_2_tailRing() [2/2]

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

Definition at line 970 of file kInline.h.

{
 
  poly t_p = p_LmInit(p, currRing, tailRing, tailBin);
  pNext(t_p) = pNext(p);
  pSetCoeff0(t_p, pGetCoeff(p));
  return t_p;
}

k_LmInit_tailRing_2_currRing() [1/2]

KINLINE poly k_LmInit_tailRing_2_currRing	(	poly	p,
		ring	tailRing
	)

Definition at line 1007 of file kInline.h.

{
  return  k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
}

k_LmInit_tailRing_2_currRing() [2/2]

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

Definition at line 979 of file kInline.h.

{
  poly p = p_LmInit(t_p, tailRing, currRing, lmBin);
  pNext(p) = pNext(t_p);
  pSetCoeff0(p, pGetCoeff(t_p));
  return p;
}

k_LmShallowCopyDelete_currRing_2_tailRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing	(	poly	p,
		ring	tailRing
	)

Definition at line 1012 of file kInline.h.

{
  return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
}

k_LmShallowCopyDelete_currRing_2_tailRing() [2/2]

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

Definition at line 988 of file kInline.h.

{
  poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
  p_LmFree(p, currRing);
  return np;
}

k_LmShallowCopyDelete_tailRing_2_currRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing	(	poly	p,
		ring	tailRing
	)

Definition at line 1017 of file kInline.h.

{
  return  k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
}

k_LmShallowCopyDelete_tailRing_2_currRing() [2/2]

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

Definition at line 995 of file kInline.h.

{
  poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
  p_LmFree(p, tailRing);
  return np;
}

ksOldCreateSpoly()

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

Definition at line 1205 of file kInline.h.

{
  LObject L(r);
  L.p1 = p1;
  L.p2 = p2;
 
  ksCreateSpoly(&L, spNoether);
  return L.GetLmCurrRing();
}

ksOldSpolyRed()

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

Definition at line 1185 of file kInline.h.

{
  LObject L(p2);
  TObject T(p1);
 
  ksReducePoly(&L, &T, spNoether);
 
  return L.GetLmCurrRing();
}

ksOldSpolyRedNew()

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

Definition at line 1195 of file kInline.h.

{
  LObject L(p_Copy(p2, currRing));
  TObject T(p1);
 
  ksReducePoly(&L, &T, spNoether);
 
  return L.GetLmCurrRing();
}

ksOldSpolyTail()

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

Definition at line 1215 of file kInline.h.

{
  LObject L(q,  currRing, r);
  TObject T(p1, currRing, r);
 
  ksReducePolyTail(&L, &T, q2, spNoether);
}

ksReducePolyTail()

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

Definition at line 1158 of file kInline.h.

{
  BOOLEAN ret;
  number coef;
 
  assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
  Red->HeadNormalize();
  ret = ksReducePoly(Red, PW, NULL, &coef);
 
  if (!ret)
  {
    if (! n_IsOne(coef, currRing->cf))
    {
      PR->Mult_nn(coef);
      // HANNES: mark for Normalize
    }
    n_Delete(&coef, currRing->cf);
  }
  return ret;
}

ksReducePolyTail_Z()

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

Definition at line 1138 of file kInline.h.

{
  BOOLEAN ret;
  number coef;
 
  assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
  ret = ksReducePoly(Red, PW, NULL, &coef);
 
  if (!ret)
  {
    if (! n_IsOne(coef, currRing->cf))
    {
      PR->Mult_nn(coef);
      // HANNES: mark for Normalize
    }
    n_Delete(&coef, currRing->cf);
  }
  return ret;
}

ksReducePolyTailLC_Z()

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

Definition at line 1120 of file kInline.h.

{
  BOOLEAN ret;
  number mult, rest;
  TObject red = *PW;
  red.Copy();
  rest = n_QuotRem(pGetCoeff(Red->p), pGetCoeff(red.p),
          &mult, currRing->cf);
  red.Mult_nn(rest);
 
  assume(PR->GetLmCurrRing() != red.GetLmCurrRing());
  ret = ksReducePolyLC(Red, &red, NULL, &mult);
  red.Delete();
  red.Clear();
 
  return ret;
}

redtailBba()

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

Definition at line 1223 of file kInline.h.

{
  LObject L(p);
  return redtailBba(&L, pos, strat,FALSE, normalize);
}

redtailBba_Ring()

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

Definition at line 1236 of file kInline.h.

{
  LObject L(p, currRing, strat->tailRing);
  return redtailBba_Ring(&L, pos, strat);
}

redtailBba_Z()

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

Definition at line 1241 of file kInline.h.

{
  LObject L(p, currRing, strat->tailRing);
  return redtailBba_Z(&L, pos, strat);
}

redtailBbaBound()

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

Definition at line 1229 of file kInline.h.

{
  LObject L(p, currRing, strat->tailRing); // ? L(p); ??
  return redtailBbaBound(&L, pos, strat,bound, FALSE, normalize);
}