spectrum.cc File Reference

#include "kernel/mod2.h"
#include "misc/mylimits.h"
#include "coeffs/numbers.h"
#include "polys/monomials/p_polys.h"
#include "polys/simpleideals.h"
#include "misc/intvec.h"
#include "polys/monomials/ring.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/spectrum/multicnt.h"
#include "kernel/spectrum/GMPrat.h"
#include "kernel/spectrum/kmatrix.h"
#include "kernel/spectrum/npolygon.h"
#include "kernel/spectrum/splist.h"
#include "kernel/spectrum/semic.h"

Go to the source code of this file.

Macros
#define	SPECTRUM_CC

Functions
BOOLEAN	hasTermOfDegree (poly h, int d, const ring r)
static BOOLEAN	hasConstTerm (poly h, const ring r)
static BOOLEAN	hasLinearTerm (poly h, const ring r)
BOOLEAN	hasAxis (ideal J, int k, const ring r)
int	hasOne (ideal J, const ring r)
int	isMultiple (poly f, poly m, const ring r)
poly	computeWC (const newtonPolygon &np, Rational max_weight, const ring r)
static poly	normalFormHC (poly f, poly hc, const ring r)
static poly	normalFormZ (poly f, poly Z, const ring r)
static int	isLeadMonomial (poly m, ideal stdJ, const ring r)
static void	setExp (poly m, int *r, const ring s)
static BOOLEAN	isWell (const ring r)
void	computeNF (ideal stdJ, poly hc, poly wc, spectrumPolyList *NF, const ring r)
BOOLEAN	ringIsLocal (const ring r)

Macro Definition Documentation

SPECTRUM_CC

#define SPECTRUM_CC

Definition at line 8 of file spectrum.cc.

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()

static BOOLEAN hasConstTerm ( poly  h, const ring  r  )

inlinestatic

Definition at line 63 of file spectrum.cc.

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

hasLinearTerm()

static BOOLEAN hasLinearTerm ( poly  h, const ring  r  )

inlinestatic

Definition at line 72 of file spectrum.cc.

{
  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;
}

isLeadMonomial()

static int isLeadMonomial ( poly  m, ideal  stdJ, const ring  r  )

inlinestatic

Definition at line 234 of file spectrum.cc.

{
  int     length = MAX_INT_VAL;
  int     result = -1;
 
  for( int i=0; i<IDELEMS(stdJ); i++ )
  {
    if( p_Cmp( stdJ->m[i],m,r )>=0 && p_DivisibleBy( stdJ->m[i],m,r ) )
    {
      int     tmp = pLength( stdJ->m[i] );
 
      if( tmp < length )
      {
        length = tmp;
        result = i;
      }
    }
  }
 
  return  result;
}

isMultiple()

int isMultiple	(	poly	f,
		poly	m,
		const ring	r
	)

Definition at line 110 of file spectrum.cc.

{
  while( f!=NULL )
  {
    // ---------------------------------------------------
    //  for a local order  f|m  is only possible if  f>=m
    // ---------------------------------------------------
 
    if( p_LmCmp( f,m,r )>=0 )
    {
      if( p_LmDivisibleByNoComp( f,m,r ) )
      {
        return  TRUE;
      }
      else
      {
        pIter( f );
      }
    }
    else
    {
      return FALSE;
    }
  }
 
  return  FALSE;
}

isWell()

static BOOLEAN isWell ( const ring  r )

static

Definition at line 274 of file spectrum.cc.

{
  int b = rBlocks( r );
 
  if( b==3 &&
      ( r->order[0] == ringorder_ds ||
        r->order[0] == ringorder_Ds ||
        r->order[0] == ringorder_ws ||
        r->order[0] == ringorder_Ws ) )
  {
    return  TRUE;
  }
  else if( b>=3
  && (( r->order[0] ==ringorder_a
        && r->block1[0]==r->N )
    || (r->order[0]==ringorder_M
        && r->block1[0]==r->N*r->N )))
  {
    for( int i=r->N-1; i>=0; i-- )
    {
      if( r->wvhdl[0][i]>=0 )
      {
        return  FALSE;
      }
    }
    return  TRUE;
  }
 
  return  FALSE;
}

normalFormHC()

static poly normalFormHC ( poly  f, poly  hc, const ring  r  )

inlinestatic

Definition at line 182 of file spectrum.cc.

{
  poly    *ptr = &f;
 
  while( (*ptr)!=NULL )
  {
    if( p_LmCmp( *ptr,hc,r )>=0 )
    {
      ptr = &(pNext( *ptr ));
    }
    else
    {
      p_Delete( ptr,r );
      return  f;
    }
  }
 
  return f;
}

normalFormZ()

static poly normalFormZ ( poly  f, poly  Z, const ring  r  )

inlinestatic

Definition at line 206 of file spectrum.cc.

{
  poly    *ptr = &f;
 
  while( (*ptr)!=NULL )
  {
    if( !isMultiple( Z,*ptr,r ) )
    {
      ptr = &(pNext( *ptr ));
    }
    else
    {
      p_LmDelete(ptr,r);
    }
  }
 
  return f;
}

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;
}

setExp()

static void setExp ( poly  m, int *  r, const ring  s  )

static

Definition at line 260 of file spectrum.cc.

{
  for( int i=s->N; i>0; i-- )
  {
    p_SetExp( m,i,r[i-1],s );
  }
  p_Setm( m,s );
}