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

{
  assume(p_sev == pGetShortExpVector(p));
  if (strat->noClearS) return;
  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
  {
    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 1018 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 1060 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 991 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 959 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 996 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 968 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 1001 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 977 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 1006 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 984 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 1194 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 1174 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 1184 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 1204 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 1147 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 1125 of file kInline.h.

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

ksReducePolyTailLC_Z()

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

Definition at line 1107 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 1212 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 1224 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 1229 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 1218 of file kInline.h.

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