hilb.h File Reference

#include "polys/monomials/ring.h"
#include "kernel/polys.h"
#include "misc/intvec.h"

Go to the source code of this file.

Functions
intvec *	hFirstSeries (ideal S, intvec *modulweight, ideal Q=NULL, intvec *wdegree=NULL)
intvec *	hFirstSeries0 (ideal S, ideal Q, intvec *wdegree, const ring src, const ring Qt)
poly	hilbert_series (ideal A, const ring src, const intvec *wdegree, const ring Qt)
intvec *	hSecondSeries (intvec *hseries1)
void	hLookSeries (ideal S, intvec *modulweight, ideal Q=NULL, intvec *wdegree=NULL)

Function Documentation

hFirstSeries()

intvec * hFirstSeries	(	ideal	S,
		intvec *	modulweight,
		ideal	Q = NULL,
		intvec *	wdegree = NULL
	)

Definition at line 2036 of file hilb.cc.

{
  static ring hilb_Qt=NULL;
  if (hilb_Qt==NULL) hilb_Qt=makeQt();
  if (!isModule(A,currRing))
    return hFirstSeries0(A,Q,wdegree,currRing,hilb_Qt);
  intvec *res=NULL;
  int w_max=0,w_min=0;
  if (module_w!=NULL)
  {
    w_max=module_w->max_in();
    w_min=module_w->min_in();
  }
  for(int c=1;c<=A->rank;c++)
  {
    ideal Ac=getModuleComp(A,c,currRing);
    intvec *res_c=hFirstSeries0(Ac,Q,wdegree,currRing,hilb_Qt);
    id_Delete(&Ac,currRing);
    intvec *tmp=NULL;
    if (res==NULL)
      res=new intvec(res_c->length()+(w_max-w_min));
    if ((module_w==NULL) || ((*module_w)[c-1]==0)) tmp=ivAdd(res,res_c);
    else tmp=ivAddShift(res, res_c,(*module_w)[c-1]-w_min);
    delete res_c;
    if (tmp!=NULL)
    {
      delete res;
      res=tmp;
    }
  }
  (*res)[res->length()-1]=w_min;
  return res;
}

hFirstSeries0()

intvec * hFirstSeries0	(	ideal	S,
		ideal	Q,
		intvec *	wdegree,
		const ring	src,
		const ring	Qt
	)

Definition at line 1952 of file hilb.cc.

{
  A=id_Head(A,src);
  id_Test(A,src);
  ideal AA;
  if (Q!=NULL)
  {
    ideal QQ=id_Head(Q,src);
    AA=id_SimpleAdd(A,QQ,src);
    id_Delete(&QQ,src);
    id_Delete(&A,src);
    idSkipZeroes(AA);
    int c=p_GetComp(AA->m[0],src);
    if (c!=0)
    {
      for(int i=0;i<IDELEMS(AA);i++)
        if (AA->m[i]!=NULL) p_SetComp(AA->m[i],c,src);
    }
  }
  else AA=A;
  id_DelDiv(AA,src);
  idSkipZeroes(AA);
   /* sort */
  if (IDELEMS(AA)>1)
  #ifdef HAVE_QSORT_R
    #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__CYGWIN__)
      qsort_r(AA->m,IDELEMS(AA),sizeof(poly),src,compare_rp);
    #else
      qsort_r(AA->m,IDELEMS(AA),sizeof(poly),compare_rp,src);
    #endif
  #else
  {
    ring r=currRing;
    currRing=src;
    qsort(AA->m,IDELEMS(AA),sizeof(poly),compare_rp_currRing);
    currRing=r;
  }
  #endif
  poly s=hilbert_series(AA,src,wdegree,Qt);
  id_Delete(&AA,src);
  intvec *ss;
  if (s==NULL)
    ss=new intvec(2);
  else
  {
    ss=new intvec(p_Totaldegree(s,Qt)+2);
    while(s!=NULL)
    {
      int i=p_Totaldegree(s,Qt);
      (*ss)[i]=n_Int(pGetCoeff(s),Qt->cf);
      if((*ss)[i]==0) Print("overflow at t^%d\n",i);
      p_LmDelete(&s,Qt);
    }
  }
  return ss;
}

hilbert_series()

poly hilbert_series	(	ideal	A,
		const ring	src,
		const intvec *	wdegree,
		const ring	Qt
	)

Definition at line 1830 of file hilb.cc.

{
  int r=id_Elem(A,src);
  poly h=NULL;
  if (r==0)
    return p_One(Qt);
  if (wdegree!=NULL)
  {
    int* exp=(int*)omAlloc((src->N+1)*sizeof(int));
    for(int i=IDELEMS(A)-1; i>=0;i--)
    {
      if (A->m[i]!=NULL)
      {
        p_GetExpV(A->m[i],exp,src);
        for(int j=src->N;j>0;j--)
        {
          int w=(*wdegree)[j-1];
          if (w<=0)
          {
            WerrorS("weights must be positive");
            return NULL;
          }
          exp[j]*=w; /* (*wdegree)[j-1] */
        }
        p_SetExpV(A->m[i],exp,src);
        #ifdef PDEBUG
        p_Setm(A->m[i],src);
        #endif
      }
    }
    omFreeSize(exp,(src->N+1)*sizeof(int));
  }
  h=p_One(Qt);
  p_SetExp(h,1,p_Totaldegree(A->m[0],src),Qt);
  p_Setm(h,Qt);
  h=p_Neg(h,Qt);
  h=p_Add_q(h,p_One(Qt),Qt); // 1-t
  int *exp_q=(int*)omAlloc((src->N+1)*sizeof(int));
  for (int i=1;i<r;i++)
  {
    //ideal J=id_Copy(A,src);
    //for (int ii=i;ii<r;ii++) p_Delete(&J->m[ii],src);
    //idSkipZeroes(J);
    ideal J=id_CopyFirstK(A,i,src);
    for(int ii=src->N;ii>0;ii--)
      exp_q[ii]=p_GetExp(A->m[i],ii,src);
    BOOLEAN *bad=(BOOLEAN*)omAlloc0(i*sizeof(BOOLEAN));
    for(int ii=0;ii<i;ii++)
    {
      bad[ii]=p_Div_hi(J->m[ii],exp_q,src);
    }
    id_DelDiv_hi(J,bad,src);
    // search linear elems:
    int k=0;
    for (int ii=IDELEMS(J)-1;ii>=0;ii--)
    {
      if((J->m[ii]!=NULL) && (p_Totaldegree(J->m[ii],src)==1))
      {
        k++;
        p_LmDelete(&J->m[ii],src);
      }
    }
    idSkipZeroes(J);
    poly h_J=hilbert_series(J,src,NULL,Qt);// J_1
    poly tmp;
    if (k>0)
    {
      // hilbert_series of unmodified J:
      tmp=p_One(Qt);
      p_SetExp(tmp,1,1,Qt);
      p_Setm(tmp,Qt);
      tmp=p_Neg(tmp,Qt);
      tmp=p_Add_q(tmp,p_One(Qt),Qt); // 1-t
      if (k>1)
      {
        tmp=p_Power(tmp,k,Qt); // (1-t)^k
      }
      h_J=p_Mult_q(h_J,tmp,Qt);
    }
    // forget about J:
    id_Delete(&J,src);
    // t^|A_i|
    tmp=p_One(Qt);
    p_SetExp(tmp,1,p_Totaldegree(A->m[i],src),Qt);
    p_Setm(tmp,Qt);
    tmp=p_Neg(tmp,Qt);
    tmp=p_Mult_q(tmp,h_J,Qt);
    h=p_Add_q(h,tmp,Qt);
  }
  omFreeSize(exp_q,(src->N+1)*sizeof(int));
  //Print("end hilbert_series, r=%d\n",r);
  return h;
}

hLookSeries()

void hLookSeries	(	ideal	S,
		intvec *	modulweight,
		ideal	Q = NULL,
		intvec *	wdegree = NULL
	)

Definition at line 776 of file hilb.cc.

{
  id_LmTest(S, currRing);
 
  intvec *hseries1 = hFirstSeries(S, modulweight, Q, wdegree);
  if (errorreported) return;
 
  hPrintHilb(hseries1,modulweight);
 
  const int l = hseries1->length()-1;
 
  intvec *hseries2 = (l > 1) ? hSecondSeries(hseries1) : hseries1;
 
  int co, mu;
  hDegreeSeries(hseries1, hseries2, &co, &mu);
 
  PrintLn();
  hPrintHilb(hseries2,modulweight);
  if ((l == 1) &&(mu == 0))
    scPrintDegree(rVar(currRing)+1, 0);
  else
    scPrintDegree(co, mu);
  if (l>1)
    delete hseries1;
  delete hseries2;
}

hSecondSeries()

intvec * hSecondSeries

(

intvec *

hseries1

)

Definition at line 697 of file hilb.cc.

{
  intvec *work, *hseries2;
  int i, j, k, t, l;
  int s;
  if (hseries1 == NULL)
    return NULL;
  work = new intvec(hseries1);
  k = l = work->length()-1;
  s = 0;
  for (i = k-1; i >= 0; i--)
    s += (*work)[i];
  loop
  {
    if ((s != 0) || (k == 1))
      break;
    s = 0;
    t = (*work)[k-1];
    k--;
    for (i = k-1; i >= 0; i--)
    {
      j = (*work)[i];
      (*work)[i] = -t;
      s += t;
      t += j;
    }
  }
  hseries2 = new intvec(k+1);
  for (i = k-1; i >= 0; i--)
    (*hseries2)[i] = (*work)[i];
  (*hseries2)[k] = (*work)[l];
  delete work;
  return hseries2;
}