spectrum.h File Reference

#include "kernel/spectrum/npolygon.h"
#include "kernel/spectrum/splist.h"

Go to the source code of this file.

Functions
BOOLEAN	hasTermOfDegree (poly h, int d, const ring r)
int	hasOne (ideal J, const ring r)
BOOLEAN	hasAxis (ideal J, int k, const ring r)
poly	computeWC (const newtonPolygon &np, Rational max_weight, const ring r)
void	computeNF (ideal stdJ, poly hc, poly wc, spectrumPolyList *NF, const ring r)
BOOLEAN	ringIsLocal (const ring r)
BOOLEAN	hasConstTerm (poly h, const ring r)
BOOLEAN	hasLinearTerm (poly h, const ring r)

Function Documentation

computeNF()

void computeNF	(	ideal	stdJ,
		poly	hc,
		poly	wc,
		spectrumPolyList *	NF,
		const ring	r
	)

Definition at line 309 of file spectrum.cc.

{
  int         carry,k;
  multiCnt    C( r->N,0 );
  poly        Z = NULL;
 
  int         well = isWell(r);
 
  do
  {
    poly    m = p_One(r);
    setExp( m,C.cnt,r );
 
    carry = FALSE;
 
    k = isLeadMonomial( m,stdJ,r );
 
    if( k < 0 )
    {
      // ---------------------------
      //  m  is not a lead monomial
      // ---------------------------
 
      NF->insert_node( m,NULL,r );
    }
    else if( isMultiple( Z,m,r ) )
    {
      // ------------------------------------
      //  m  is trivially in the ideal  stdJ
      // ------------------------------------
 
      p_Delete( &m,r );
      carry = TRUE;
    }
    else if( p_Cmp( m,hc,r ) < 0 || p_Cmp( m,wc,r ) < 0 )
    {
      // -------------------
      //  we do not need  m
      // -------------------
 
      p_Delete( &m,r );
      carry = TRUE;
    }
    else
    {
      // --------------------------
      //  compute lazy normal form
      // --------------------------
 
      poly    multiplicant = p_MDivide( m,stdJ->m[k],r );
      pGetCoeff( multiplicant ) = n_Init(1,r->cf);
 
      poly    nf = p_Mult_mm( p_Copy( stdJ->m[k],r ), multiplicant,r );
 
      p_Delete( &multiplicant,r );
 
      nf = normalFormHC( nf,hc,r );
 
      if( pNext( nf )==NULL )
      {
        // ----------------------------------
        //  normal form of  m  is  m  itself
        // ----------------------------------
 
        p_Delete( &nf,r );
        NF->delete_monomial( m,r );
        Z = p_Add_q( Z,m,r );
        carry = TRUE;
      }
      else
      {
        nf = normalFormZ( nf,Z,r );
 
        if( pNext( nf )==NULL )
        {
          // ----------------------------------
          //  normal form of  m  is  m  itself
          // ----------------------------------
 
          p_Delete( &nf,r );
          NF->delete_monomial( m,r );
          Z = p_Add_q( Z,m,r );
          carry = TRUE;
        }
        else
        {
          // ------------------------------------
          //  normal form of  m  is a polynomial
          // ------------------------------------
 
          p_Norm( nf,r );
          if( well==TRUE )
          {
            NF->insert_node( m,nf,r );
          }
          else
          {
            poly    nfhard = kNF( stdJ,(ideal)NULL,pNext( nf ),0,0 );
            nfhard = normalFormHC( nfhard,hc,r );
            nfhard = normalFormZ ( nfhard,Z,r );
 
            if( nfhard==NULL )
            {
              NF->delete_monomial( m,r );
              Z = p_Add_q( Z,m,r );
              carry = TRUE;
            }
            else
            {
              p_Delete( &pNext( nf ),r );
              pNext( nf ) = nfhard;
              NF->insert_node( m,nf,r );
            }
          }
        }
      }
    }
  }
  while( C.inc( carry ) );
 
  // delete single monomials
 
  BOOLEAN  not_finished;
 
  do
  {
    not_finished = FALSE;
 
    spectrumPolyNode  *node = NF->root;
 
    while( node!=(spectrumPolyNode*)NULL )
    {
      if( node->nf!=NULL && pNext( node->nf )==NULL )
      {
        NF->delete_monomial( node->nf,r );
        not_finished = TRUE;
        node = (spectrumPolyNode*)NULL;
      }
      else
      {
        node = node->next;
      }
    }
  } while( not_finished );
 
  p_Delete( &Z,r );
}

computeWC()

poly computeWC	(	const newtonPolygon &	np,
		Rational	max_weight,
		const ring	r
	)

Definition at line 142 of file spectrum.cc.

{
  poly m  = p_One(r);
  poly wc = NULL;
  int  mdegree;
 
  for( int i=1; i<=r->N; i++ )
  {
    mdegree = 1;
    p_SetExp( m,i,mdegree,r );
    // pSetm( m );
    // np.weight_shift does not need pSetm( m ), postpone it
 
    while(  np.weight_shift( m,r )<max_weight )
    {
      mdegree++;
      p_SetExp( m,i,mdegree,r );
      // pSetm( m );
      // np.weight_shift does not need pSetm( m ), postpone it
    }
    p_Setm( m,r );
 
    if( i==1 || p_Cmp( m,wc,r )<0 )
    {
      p_Delete( &wc,r );
      wc = p_Head( m,r );
    }
 
    p_SetExp( m,i,0,r );
  }
 
  p_Delete( &m,r );
 
  return  wc;
}

hasAxis()

BOOLEAN hasAxis	(	ideal	J,
		int	k,
		const ring	r
	)

Definition at line 81 of file spectrum.cc.

{
  int i;
 
  for( i=0; i<IDELEMS(J); i++ )
  {
    if (p_IsPurePower( J->m[i],r ) == k) return TRUE;
  }
  return  FALSE;
}

hasConstTerm()

BOOLEAN hasConstTerm ( poly  h, const ring  r  )

inline

Definition at line 28 of file spectrum.h.

{ return  hasTermOfDegree(h,0,r); }

hasLinearTerm()

BOOLEAN hasLinearTerm ( poly  h, const ring  r  )

inline

Definition at line 30 of file spectrum.h.

{ return  hasTermOfDegree(h,1,r); }

hasOne()

int hasOne	(	ideal	J,
		const ring	r
	)

Definition at line 96 of file spectrum.cc.

{
  int i;
 
  for( i=0; i<IDELEMS(J); i++ )
  {
    if (p_IsConstant(J->m[i],r)) return TRUE;
  }
  return  FALSE;
}

hasTermOfDegree()

BOOLEAN hasTermOfDegree	(	poly	h,
		int	d,
		const ring	r
	)

Definition at line 46 of file spectrum.cc.

{
  do
  {
    if( p_Totaldegree( h,r )== d )
      return  TRUE;
    pIter(h);
  }
  while( h!=NULL );
 
  return  FALSE;
}

ringIsLocal()

BOOLEAN ringIsLocal

(

const ring

r

)

Definition at line 461 of file spectrum.cc.

{
  poly    m   = p_One(r);
  poly    one = p_One(r);
  BOOLEAN res=TRUE;
 
  for( int i=r->N; i>0; i-- )
  {
    p_SetExp( m,i,1,r );
    p_Setm( m,r );
 
    if( p_Cmp( m,one,r )>0 )
    {
      res=FALSE;
      break;
    }
    p_SetExp( m,i,0,r );
  }
 
  p_Delete( &m,r );
  p_Delete( &one,r );
 
  return  res;
}