janet.cc File Reference

#include "kernel/mod2.h"
#include "coeffs/numbers.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "polys/kbuckets.h"
#include "kernel/ideals.h"
#include "kernel/polys.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/GBEngine/janet.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>

Go to the source code of this file.

Macros
#define	pow_(x)

Functions
int	ReducePolyLead (Poly *x, Poly *y)
int	ReducePoly (Poly *x, poly from, Poly *y)
void	PNF (Poly *p, TreeM *F)
void	NFL (Poly *p, TreeM *F)
int	ValidatePoly (Poly *x, TreeM *)
Poly *	NewPoly (poly p)
void	DestroyPoly (Poly *x)
void	ControlProlong (Poly *x)
void	InitHistory (Poly *p)
void	InitLead (Poly *p)
void	InitProl (Poly *p)
int	GetMult (Poly *x, int i)
void	SetMult (Poly *x, int i)
void	ClearMult (Poly *x, int i)
int	GetProl (Poly *x, int i)
void	SetProl (Poly *x, int i)
void	ClearProl (Poly *x, int i)
int	LengthCompare (poly p1, poly p2)
int	ProlCompare (Poly *item1, Poly *item2)
void	ProlVar (Poly *temp, int i)
void	DestroyListNode (ListNode *x)
ListNode *	CreateListNode (Poly *x)
Poly *	FindMinList (jList *L)
void	InsertInList (jList *x, Poly *y)
void	InsertInCount (jList *x, Poly *y)
int	ListGreatMoveOrder (jList *A, jList *B, poly x)
int	ListGreatMoveDegree (jList *A, jList *B, poly x)
int	CountList (jList *Q)
void	NFListQ ()
void	ForEachPNF (jList *x, int i)
void	ForEachControlProlong (jList *x)
void	DestroyList (jList *x)
Poly *	is_present (jList *F, poly x)
int	GB_length ()
NodeM *	create ()
void	DestroyFreeNodes ()
void	DestroyTree (NodeM *G)
void	Define (TreeM **G)
int	sp_div (poly m1, poly m2, int from)
void	div_l (poly item, NodeM *x, int from)
Poly *	is_div_upper (poly item, NodeM *x, int from)
Poly *	is_div_ (TreeM *tree, poly item)
static void	ClearMultiplicative (NodeM *xx, int i)
void	insert_ (TreeM **tree, Poly *item)
void	Initialization (char *Ord)
void	T2G ()
int	ComputeBasis (jList *_lT, jList *_lQ)

Variables
STATIC_VAR int	offset
STATIC_VAR jList *	T
STATIC_VAR jList *	Q
STATIC_VAR TreeM *	G
STATIC_VAR NodeM *	FreeNodes
STATIC_VAR int	degree_compatible
STATIC_VAR int(*	ListGreatMove )(jList *, jList *, poly)
STATIC_VAR int	Mask [8] ={0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x1}
VAR pFDegProc	jDeg
STATIC_VAR Poly *	temp_l
STATIC_VAR Poly *	h

Macro Definition Documentation

pow_

#define pow_

(

x

)

Value:

jDeg((x),currRing)

Definition at line 43 of file janet.cc.

Function Documentation

ClearMult()

void ClearMult	(	Poly *	x,
		int	i )

Definition at line 431 of file janet.cc.

{
  x->mult[i/8] &= ~Mask[i%8];
}

ClearMultiplicative()

void ClearMultiplicative ( NodeM * xx, int i )

static

Definition at line 894 of file janet.cc.

{
  if (!xx) return;
 
  while (xx->left)
  {
    ClearMultiplicative(xx->right, i);
    xx = xx->left;
  }
  if ((xx->ended) && (GetMult(xx->ended,i)))
  {
    ClearMult(xx->ended,i);
    ProlVar(xx->ended,i);
  }
  else
    ClearMultiplicative(xx->right,i);
}

ClearProl()

void ClearProl	(	Poly *	x,
		int	i )

Definition at line 446 of file janet.cc.

{
  (x->mult+offset)[i/8] &= ~Mask[i%8];
}

ComputeBasis()

int ComputeBasis	(	jList *	_lT,
		jList *	_lQ )

Definition at line 1000 of file janet.cc.

{
  // int gb_l,i,ret_value=1;
 
  T=_lT; Q=_lQ;
 
//  Debug();
 
  while((h=FindMinList(Q))!=NULL)
  {
//        PrintS("New element\n");
//  Debug();
 
        if (!degree_compatible)
        {
          if (!ValidatePoly(h,G))
          {
            DestroyPoly(h);
            continue;
          }
 
          h->changed=0;
 
          NFL(h,G);
 
          if (!h->root)
          {
            DestroyPoly(h);
            continue;
          }
        }
 
        if (h->root)
        {
          if (pIsConstant(h->root))
          {
            WarnS("Constant in basis\n");
            return 0;
          }
 
          if (h->changed && ListGreatMove(T,Q,h->root))
          {
//      PrintS("<-\n");
            DestroyTree(G->root);
            G->root=create();
            T2G();
          }
        }
 
//  PrintS("PNF\n");
        PNF(h,G);
//        Print("{%d}\n",pow_(h->root));
        insert_(&G,h);
        InsertInList(T,h);
 
//  PrintS("For each PNF\n");
        if (degree_compatible)
            ForEachPNF(T,pow_(h->root));
 
//  PrintS("Control of prolongations\n");
        if (h->changed)
            ForEachControlProlong(T);
        else
            ControlProlong(h);
 
//  Debug();
 
//  PrintS("NFListQ\n");
        if (degree_compatible)
            NFListQ();
//Debug();
    }
 
//    gb_l=GB_length();
 
    Print("Length of Janet basis: %d\n",CountList(T));
//    Print("Length of Groebner basis:    %d\n",gb_l);
 
    DestroyTree(G->root);
    GCF(G);
    DestroyFreeNodes();
 
    return 1;
}

ControlProlong()

void ControlProlong

(

Poly *

x

)

Definition at line 392 of file janet.cc.

{
  for (int i = 0; i< offset; i++)
  {
    (x->mult+offset)[i]&=~((x->mult)[i]);
//    if (!GetMult(x,i) && !GetProl(x,i))
//      ProlVar(x,i);
  }
}

CountList()

int CountList

(

jList *

Q

)

Definition at line 617 of file janet.cc.

{
  int i=0;
  LCI y=Q->root;
 
  while(y)
  {
    i++;
    y=y->next;
  }
 
  return i;
}

create()

NodeM * create

(

)

Definition at line 757 of file janet.cc.

{
  NodeM *y;
 
  if (FreeNodes == NULL)
  {
    y=(NodeM *)GCM(sizeof(NodeM));
  }
  else
  {
    y=FreeNodes;
    FreeNodes=FreeNodes->left;
  }
 
  y->left=y->right=NULL;
  y->ended=NULL;
  return y;
}

CreateListNode()

ListNode * CreateListNode

(

Poly *

x

)

Definition at line 508 of file janet.cc.

{
  ListNode* ret=(ListNode *)GCM(sizeof(ListNode));
  ret->info=x;
  ret->next=NULL;
  return ret;
}

Define()

void Define

(

TreeM **

G

)

Definition at line 815 of file janet.cc.

{
  *G=(TreeM *)GCM(sizeof(TreeM));
  (*G)->root=create();
}

DestroyFreeNodes()

void DestroyFreeNodes

(

)

Definition at line 776 of file janet.cc.

{
  NodeM *y;
 
  while((y=FreeNodes)!=NULL)
  {
    FreeNodes=FreeNodes->left;
    GCF(y);
  }
}

DestroyList()

void DestroyList

(

jList *

x

)

Definition at line 714 of file janet.cc.

{
  LCI y=x->root,z;
 
  while(y)
  {
    z=y->next;
    DestroyPoly(y->info);
    GCF(y);
    y=z;
  }
 
  GCF(x);
}

DestroyListNode()

void DestroyListNode

(

ListNode *

x

)

Definition at line 502 of file janet.cc.

{
  DestroyPoly(x->info);
  GCF(x);
}

DestroyPoly()

void DestroyPoly

(

Poly *

x

)

Definition at line 383 of file janet.cc.

{
  pDelete(&x->root);
  pLmFree(&x->history);
  if (x->lead!=NULL) pLmFree(&x->lead);
  GCF(x->mult);
  GCF(x);
}

DestroyTree()

void DestroyTree

(

NodeM *

G

)

Definition at line 804 of file janet.cc.

{
  if (G)
  {
    DestroyTree(G->left);
    DestroyTree(G->right);
    G->left=FreeNodes;
    FreeNodes=G;
  }
}

div_l()

void div_l	(	poly	item,
		NodeM *	x,
		int	from )

Definition at line 832 of file janet.cc.

{
  if (x && !temp_l)
  {
    div_l(item,x->left,from);
    if ((x->ended) && sp_div(item,x->ended->root,from))
    {
      temp_l=x->ended;
      return;
    };
    div_l(item,x->right,from);
  }
}

FindMinList()

Poly * FindMinList

(

jList *

L

)

Definition at line 517 of file janet.cc.

{
  LI min=&(L->root);
  LI l;
  LCI xl;
  Poly *x;
 
  if (degree_compatible)
  {
    while ((*min) && ((*min)->info->root == NULL))
      min=&((*min)->next);
  }
 
  if (!(*min)) return NULL;
 
  l=&((*min)->next);
 
  while (*l)
  {
    if ((*l)->info->root != NULL)
    {
      if (ProlCompare((*l)->info,(*min)->info))
        min=l;
    }
 
    l=&((*l)->next);
  }
  x=(*min)->info;
  xl=*min;
  *min=(*min)->next;
  GCF(xl);
 
  return x;
}

ForEachControlProlong()

void ForEachControlProlong

(

jList *

x

)

Definition at line 703 of file janet.cc.

{
  LCI y=x->root;
 
  while(y)
  {
    ControlProlong(y->info);
    y=y->next;
  }
}

ForEachPNF()

void ForEachPNF	(	jList *	x,
		int	i )

Definition at line 692 of file janet.cc.

{
  LCI y=x->root;
 
  while(y)
  {
    if (pow_(y->info->root) == i) PNF(y->info,G);
    y=y->next;
  }
}

GB_length()

int GB_length

(

)

Definition at line 740 of file janet.cc.

{
  LCI iT=T->root;
  int l=0;
 
  while(iT)
  {
    if (pow_(iT->info->lead) == pow_(iT->info->history))
      ++l;
    iT=iT->next;
  }
 
  return l;
}

GetMult()

int GetMult	(	Poly *	x,
		int	i )

Definition at line 421 of file janet.cc.

{
  return x->mult[i/8] & Mask[i%8];
}

GetProl()

int GetProl	(	Poly *	x,
		int	i )

Definition at line 436 of file janet.cc.

{
  return (x->mult+offset)[i/8] & Mask[i%8];
}

InitHistory()

void InitHistory

(

Poly *

p

)

Definition at line 402 of file janet.cc.

{
  if (p->history) pLmFree(&p->history);
  p->history=pLmInit(p->root);
  p->changed=0;
}

Initialization()

void Initialization

(

char *

Ord

)

Definition at line 952 of file janet.cc.

{
  offset=(currRing->N % 8 == 0) ? (currRing->N/8)*8 : (currRing->N/8+1)*8;
  if (strstr(Ord,"dp\0") || strstr(Ord,"Dp\0"))
  {
    degree_compatible=1;
    jDeg=p_Deg;
    ListGreatMove=ListGreatMoveDegree;
  }
  else
  {
    degree_compatible=0;
    jDeg=p_Totaldegree;
    ListGreatMove=ListGreatMoveOrder;
  }
 
  Define(&G);
}

InitLead()

void InitLead

(

Poly *

p

)

Definition at line 409 of file janet.cc.

{
  if (p->lead!=NULL) pLmFree(&p->lead);
  p->lead=pLmInit(p->root);
  p->prolonged=-1;
}

InitProl()

void InitProl

(

Poly *

p

)

Definition at line 416 of file janet.cc.

{
  memset(p->mult+offset,0,sizeof(char)*offset);
}

insert_()

void insert_	(	TreeM **	tree,
		Poly *	item )

Definition at line 912 of file janet.cc.

{
 int power_tmp,i,i_con=currRing->N-1;
 NodeM *curr=(*tree)->root;
 
 for ( ; (i_con>=0) && !pGetExp(item->root,i_con+1) ; i_con--)
  SetMult(item,i_con);
 
 for (i = 0; i<= i_con; i++)
 //<=
 {
  power_tmp=pGetExp(item->root,i+1);
 
  ClearMult(item,i);
 
  while (power_tmp)
  {
   if (!curr->left)
   {
     SetMult(item,i);
     ClearMultiplicative(curr->right,i);
     curr->left=create();
   };
   curr=curr->left;
   power_tmp--;
  };
 
  if (i<i_con)
  {
   if (!curr->left) SetMult(item,i);
   if (!curr->right) curr->right=create();
   curr=curr->right;
 
   ProlVar(item,i);
  }
 }
 
 curr->ended=item;
}

InsertInCount()

void InsertInCount	(	jList *	x,
		Poly *	y )

Definition at line 571 of file janet.cc.

{
  ListNode *ins;
  LI ix=&(x->root);
 
  ins=CreateListNode(y);
  ins->next=(ListNode *)(*ix);
  *ix=ins;
  return;
}

InsertInList()

void InsertInList	(	jList *	x,
		Poly *	y )

Definition at line 552 of file janet.cc.

{
  ListNode *ins;
  LI ix=&(x->root);
 
  while (*ix)
  {
    if (pLmCmp(y->lead,(*ix)->info->lead) == -1)
      ix=(ListNode **)&((*ix)->next);
    else
      break;
  }
 
  ins=CreateListNode(y);
  ins->next=(ListNode *)(*ix);
  *ix=ins;
  return;
}

is_div_()

Poly * is_div_	(	TreeM *	tree,
		poly	item )

Definition at line 853 of file janet.cc.

{
  int power_tmp,i,i_con=currRing->N-1;
  NodeM *curr=tree->root;
 
  if (!curr) return NULL;
  if (pow_(item) == 0) return NULL;
 
  for ( ; i_con>=0 && !pGetExp(item,i_con+1) ; i_con--)
    ;
 
  for (i=0; i <= i_con ; i++)
  {
    power_tmp=pGetExp(item,i+1);
 
    while (power_tmp)
    {
      if (curr->ended) return curr->ended;
 
      if (!curr->left)
      {
        if (curr->right)
          return is_div_upper(item,curr->right,i); //??????
        return NULL;
      }
 
      curr=curr->left;
      power_tmp--;
    }
 
    if (curr->ended) return curr->ended;
 
    if (!curr->right) return NULL;
 
    curr=curr->right;
  }
 
  if (curr->ended) return curr->ended;
  else return NULL;
}

is_div_upper()

Poly * is_div_upper	(	poly	item,
		NodeM *	x,
		int	from )

Definition at line 846 of file janet.cc.

{
  temp_l=NULL;
  div_l(item,x,from);
  return temp_l;
}

is_present()

Poly * is_present	(	jList *	F,
		poly	x )

Definition at line 729 of file janet.cc.

{
  LCI iF=F->root;
  while(iF)
    if (pLmCmp(iF->info->root,x) == 0)
      return iF->info;
    else iF=iF->next;
 
  return NULL;
}

LengthCompare()

int LengthCompare	(	poly	p1,
		poly	p2 )

Definition at line 451 of file janet.cc.

{
  do
  {
    if (p1 == NULL) return 1;
    if (p2 == NULL) return 0;
    pIter(p1);
    pIter(p2);
  }while(p1 && p2);
  return 1;
}

ListGreatMoveDegree()

int ListGreatMoveDegree	(	jList *	A,
		jList *	B,
		poly	x )

Definition at line 599 of file janet.cc.

{
  LCI y=A->root;
  int pow_x=pow_(x);
 
  if (!y || pow_(y->info->lead) <= pow_x) return 0;
 
  while(y && pow_(y->info->lead) > pow_x)
  {
    InsertInCount(B,y->info);
    A->root=y->next;
    GCF(y);
    y=A->root;
  }
 
  return 1;
}

ListGreatMoveOrder()

int ListGreatMoveOrder	(	jList *	A,
		jList *	B,
		poly	x )

Definition at line 582 of file janet.cc.

{
  LCI y=A->root;
 
  if (!y || pLmCmp(y->info->lead,x) < 0) return 0;
 
  while(y && pLmCmp(y->info->lead,x) >= 0)
  {
    InsertInCount(B,y->info);
    A->root=y->next;
    GCF(y);
    y=A->root;
  }
 
  return 1;
}

NewPoly()

Poly * NewPoly

(

poly

p

)

Definition at line 361 of file janet.cc.

{
  Poly *beg=(Poly *)GCM(sizeof(Poly));
 
  beg->root=p;//(p == NULL ? pInit() : p);
  beg->root_b=NULL;
  beg->root_l=0;
  beg->history=NULL;//pInit();
  beg->lead=NULL;
  beg->mult=(char *)GCMA(sizeof(char)*2*offset);
 
  for (int i=0; i < currRing->N; i++)
  {
    ClearMult(beg,i);
    ClearProl(beg,i);
  };
 
  beg->prolonged=-1;
 
  return beg;
}

NFL()

void NFL	(	Poly *	p,
		TreeM *	F )

Definition at line 187 of file janet.cc.

{
  Poly *f;
  // int g1,f1,gg;
 
  if ((f=is_div_(F,p->lead))==NULL) return;
 
  int pX=pow_(p->lead);
  int phX=pow_(p->history);
 
  if (pX!=phX)
  {
    int phF=pow_(f->history);
    if (pX >= (phX+phF))
    {
      pDelete(&p->root);
      //p->root=NULL;
      return;
    }
 
/*    poly p2=pInit();
    pLcm(p->history,f->history,p2);
    pSetm(p2);
 
    if (pLmCmp(p->root,p2) > 0)
    {
      pLmDelete(&p2);
      pDelete(&p->root);
      //p->root=NULL;
      return;
    }
 
    pLmDelete(&p2);
*/
/*    for(int i=0, gg=0 ; i<currRing->N;i++)
      if ((g1=pGetExp(p->history,i+1)) > (f1=pGetExp(f->history,i+1)))
        gg+=g1;
      else gg+=f1;
 
    if (pX > gg)
      {
        pDelete(&p->root);
        //x->root=NULL;
        return;
    }
*/
    int pF=pow_(f->lead);
 
    if ((pX == pF) && (pF == phF))
    {
      pLmFree(&f->history);
      if (p->history!=NULL)
        f->history=p_Copy_noCheck(p->history,currRing); /* cf of p->history is NULL */
    }
  }
 
  //if (TEST_OPT_PROT) { PrintS("R"); mflush(); }
  int /*old_size, */count;
  count=0;
  while(f && p->root)
  {
//    PrintS("R");
//    if (TEST_OPT_PROT) { PrintS("R"); mflush(); }
#if 0
    old_size=nSize(pGetCoeff(p->root));
#endif
    if (ReducePolyLead(p,f) == 0) break;
    if (p->root!=NULL)
    {
      count++;
#if 0
      if ((count>4) && (3<nSize(pGetCoeff(p->root)))
      && (nSize(pGetCoeff(p->root))>old_size))
      {
        p_SimpleContent(p->root,old_size,currRing);
        count=0;
      }
#else
      if (count>50)
      {
        kBucketClear(p->root_b,&p->root,&p->root_l);
        p_SimpleContent(p->root,2,currRing);
        kBucketInit(p->root_b,p->root,p->root_l);
        count=0;
        //PrintS(".");
      }
#endif
      f=is_div_(F,p->root);
    }
  }
#if 1
  if (p->root_b!=NULL)
  {
    kBucketClear(p->root_b,&p->root,&p->root_l);
    kBucketDestroy(&p->root_b);
    p->root_b=NULL;
  }
#endif
 
  if (!p->root)
    return;
 
  InitHistory(p);
  InitProl(p);
  InitLead(p);
  p->changed=1;
 
  p_ContentForGB(p->root,currRing);
  //p_SimpleContent(p->root,-1i,currRing);
  pTest(p->root);
}

NFListQ()

void NFListQ

(

)

Definition at line 631 of file janet.cc.

{
  LCI ll;
  int p,p1;
  LI l;
 
  do
  {
    if (!Q->root) break;
 
    ll=Q->root;
 
    p=pow_(Q->root->info->lead);
 
    while (ll)
    {
      int ploc=pow_(ll->info->lead);
      if (ploc < p) p=ploc;
      ll=ll->next;
    }
 
    p1=1;
 
    l=&(Q->root);
 
    while (*l)
    {
//      PrintS("*");
      int ploc=pow_((*l)->info->lead);
 
      if (ploc == p)
      {
        if (!ValidatePoly((*l)->info,G))
        {
          ll=(*l);
          *l=(*l)->next;
          DestroyListNode(ll);
          continue;
        };
 
        (*l)->info->changed=0;
//        PrintS("!");
        NFL((*l)->info,G);
//                                PrintS("$");
        if (!(*l)->info->root)
        {
          ll=(*l);
          *l=(*l)->next;
          DestroyListNode(ll);
          continue;
        };
        p1=0;
      }
 
      l=&((*l)->next);
    }
  }while(p1);
//  PrintLn();
}

PNF()

void PNF	(	Poly *	p,
		TreeM *	F )

Definition at line 143 of file janet.cc.

{
  if (p->root==NULL) return;
 
  Poly *f;
  BOOLEAN done=FALSE;
  poly temp=p->root;
 
//  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
  int count=0;
  poly pp=p->root;
  int old_size=nSize(pGetCoeff(pp));
  p->root_l=0;
  while(temp->next)
  {
    f=is_div_(F,temp->next);
    if (f)
    {
      if (ReducePoly(p,temp,f)) //temp->next
      {
        count++;
        //if (TEST_OPT_PROT) { PrintS("-"); mflush(); }
        if ((f!=NULL)
        && (count>20)
        && (nSize(pGetCoeff(pp))>old_size)
        )
        {
           p_SimpleContent(pp,1,currRing);
           //p_Content(pp,currRing);
           count=0;
         //  old_size=nSize(pGetCoeff(pp));
        }
      }
      done=TRUE;
    }
    else
      temp=temp->next;
   }
 
  if (done) p_ContentForGB(p->root,currRing);
  //if (done) p_SimpleContent(p->root,-1,currRing);
  pTest(p->root);
}

ProlCompare()

int ProlCompare	(	Poly *	item1,
		Poly *	item2 )

Definition at line 463 of file janet.cc.

{
  switch(pLmCmp(item1->lead,item2->lead))
  {
    case -1:
      return 1;
 
    case 1:
      return 0;
 
    default:
      if ((item1->root_l<=0)||(item2->root_l<=0))
        return LengthCompare(item1->root,item2->root);
      return item1->root_l<=item2->root_l;
  }
}

ProlVar()

void ProlVar	(	Poly *	temp,
		int	i )

Definition at line 480 of file janet.cc.

{
  Poly *Pr;
 
  if (!GetProl(temp,i) && !GetMult(temp,i))
  {
    Pr=NewPoly();
    SetProl(temp,i);
 
    Pr->prolonged=i;
    Pr->history=pLmInit(temp->history);
    Pr->lead=pLmInit(temp->lead);
    pIncrExp(Pr->lead,i+1);
    pSetm(Pr->lead);
    InitProl(temp);
 
     Pr->changed=0;
//    pTest(Pr->root);
      InsertInCount(Q,Pr);
   }
}

ReducePoly()

int ReducePoly	(	Poly *	x,
		poly	from,
		Poly *	y )

Definition at line 119 of file janet.cc.

{
  if (!x->root || !y->root)
    return 0;
 
/*  poly b1=pMDivide(from,y->root);
 
  number gcd=n_Gcd(pGetCoeff(from),pGetCoeff(y->root),currRing->cf);
 
  number a1=nDiv(pGetCoeff(y->root),gcd);
  pGetCoeff(b1)=nDiv(pGetCoeff(from),gcd);
 
  x->root=pMult_nn(x->root,a1);
  nDelete(&a1);*/
 
//  x->root=pMinus_mm_Mult_qq(x->root,b1,y->root);
//  pDelete(&b1);
 
  ksOldSpolyTail(y->root,x->root,from,NULL,currRing);
  y->root_l=0;
 
  return 1;
}

ReducePolyLead()

int ReducePolyLead	(	Poly *	x,
		Poly *	y )

Definition at line 74 of file janet.cc.

{
  if (!x->root || !y->root)
    return 0;
 
/*  poly b1=pMDivide(x->root,y->root);
 
  number gcd=n_Gcd(pGetCoeff(x->root),pGetCoeff(y->root),currRing->cf);
 
  number a1=nDiv(pGetCoeff(y->root),gcd);
  pGetCoeff(b1)=nDiv(pGetCoeff(x->root),gcd);
 
  x->root=pMult_nn(x->root,a1);
  nDelete(&a1);
 
  x->root=pMinus_mm_Mult_qq(x->root,b1,y->root);
 
  pDelete(&b1);
*/
#if 1
  if (x->root_b==NULL)
  {
    if (x->root_l<=0) x->root_l=pLength(x->root);
    x->root_b=kBucketCreate(currRing);
    kBucketInit(x->root_b,x->root,x->root_l);
  }
  number coef;
  if (y->root_l<=0) y->root_l=pLength(y->root);
  coef=kBucketPolyRed(x->root_b,y->root,y->root_l,NULL);
  nDelete(&coef);
  x->root=kBucketGetLm(x->root_b);
  if (x->root==NULL)
  {
    kBucketDestroy(&x->root_b);
    x->root_b=NULL;
    x->root_l=0;
  }
#else
  x->root=ksOldSpolyRed(y->root,x->root,NULL);
#endif
//  if (x->root) p_SimpleContent(x->root,5,currRing);
 
  return 1;
}

SetMult()

void SetMult	(	Poly *	x,
		int	i )

Definition at line 426 of file janet.cc.

{
  x->mult[i/8] |= Mask[i%8];
}

SetProl()

void SetProl	(	Poly *	x,
		int	i )

Definition at line 441 of file janet.cc.

{
  (x->mult+offset)[i/8] |= Mask[i%8];
}

sp_div()

int sp_div	(	poly	m1,
		poly	m2,
		int	from )

Definition at line 821 of file janet.cc.

{
 
  if (pow_(m2) == 0 && pow_(m1)) return 0;
 
  for(int k=from; k < currRing->N; k++)
    if (pGetExp(m1,k+1) < pGetExp(m2,k+1)) return 0;
 
  return 1;
}

T2G()

void T2G

(

)

Definition at line 1085 of file janet.cc.

{
 LCI i=T->root;
 while (i)
 {
  insert_(&G,i->info);
  i=i->next;
 }
}

ValidatePoly()

int ValidatePoly	(	Poly *	x,
		TreeM *	)

Definition at line 299 of file janet.cc.

{
  Poly /*f,*/*g;
  // int g1,f1;
 
  if (x->root) return 1;
 
  g=is_present(T,x->history); //it's a prolongation - do we have a parent ?
 
  if (!g)  return 0; //if not - kill him !
 
  poly lmX=pMDivide(x->lead,g->root);
  pSetCoeff0(lmX,nInit(1));
 
/*  if ((f=is_div_(F,lmX)) != NULL)
  {
    int pX=pow_(lmX);
    int phX=pow_(x->history);
 
    if (pX!=phX)
    {
      int phF=pow_(f->history);
      if (pX >= (phX+phF))
      {
        pLmDelete(&lmX);
        //x->root=NULL;
        return 0;
      }
 
      for(int i=0, gg=0 ; i<currRing->N;i++)
        if ((g1=pGetExp(x->history,i+1)) > (f1=pGetExp(f->history,i+1)))
          gg+=g1;
        else
          gg+=f1;
 
      if (pX > gg)
      {
        pLmDelete(&lmX);
        return 0;
      }
      int pF=pow_(f->root);
 
      if ((pX == pF) && (pF == phF))
        f->history=x->history;
    }
  }
 
  pLmDelete(&lmX);
 
*/
  x->root=pCopy(g->root);
  x->root_l=g->root_l;
 
  x->root=pMult(x->root,lmX);
 
  pTest(x->root);
 
  x->prolonged=-1;
 
  return 1;
}

Variable Documentation

degree_compatible

STATIC_VAR int degree_compatible

Definition at line 34 of file janet.cc.

FreeNodes

STATIC_VAR NodeM* FreeNodes

Definition at line 33 of file janet.cc.

G

STATIC_VAR TreeM* G

Definition at line 31 of file janet.cc.

h

STATIC_VAR Poly* h

Definition at line 971 of file janet.cc.

jDeg

VAR pFDegProc jDeg

Definition at line 42 of file janet.cc.

ListGreatMove

STATIC_VAR int(* ListGreatMove) (jList *, jList *, poly)	(	jList *	,
		jList *	,
		poly	)

Definition at line 35 of file janet.cc.

Mask

STATIC_VAR int Mask[8] ={0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x1}

Definition at line 36 of file janet.cc.

offset

STATIC_VAR int offset

Definition at line 29 of file janet.cc.

Q

STATIC_VAR jList * Q

Definition at line 30 of file janet.cc.

T

STATIC_VAR jList* T

Definition at line 30 of file janet.cc.

temp_l

STATIC_VAR Poly* temp_l

Definition at line 755 of file janet.cc.