fglm.h File Reference

#include "kernel/mod2.h"
#include "kernel/ideals.h"
#include "kernel/structs.h"

Go to the source code of this file.

Functions
BOOLEAN	fglmProc (leftv result, leftv first, leftv second)
BOOLEAN	fglmQuotProc (leftv result, leftv first, leftv second)
ideal	fglmQuot (ideal first, poly second)
BOOLEAN	FindUnivariateWrapper (ideal source, ideal &dest)
BOOLEAN	findUniProc (leftv result, leftv first)
ideal	findUni (ideal first)
ideal	fglmhomProc (leftv first, leftv second)

Function Documentation

fglmhomProc()

ideal fglmhomProc	(	leftv	first,
		leftv	second
	)

fglmProc()

BOOLEAN fglmProc	(	leftv	result,
		leftv	first,
		leftv	second
	)

Definition at line 277 of file fglm.cc.

{
    FglmState state = FglmOk;
 
    ring destRing = currRing;
    // ring destRing = currRing;
    ideal destIdeal = NULL;
    ring sourceRing = (ring)first->Data();
    rChangeCurrRing( sourceRing );
    // ring sourceRing = currRing;
 
    int * vperm = (int *)omAlloc0( (sourceRing->N+1)*sizeof( int ) );
    state= fglmConsistency( sourceRing, destRing, vperm );
    omFreeSize( (ADDRESS)vperm, (sourceRing->N+1)*sizeof(int) );
 
    if ( state == FglmOk )
    {
        idhdl ih = sourceRing->idroot->get( second->Name(), myynest );
        if ( (ih != NULL) && (IDTYP(ih)==IDEAL_CMD) )
        {
            ideal sourceIdeal;
            if ( sourceRing->qideal != NULL )
                sourceIdeal= fglmUpdatesource( IDIDEAL( ih ) );
            else
                sourceIdeal = IDIDEAL( ih );
            state= fglmIdealcheck( sourceIdeal );
            if ( state == FglmOk )
            {
                // Now the settings are compatible with FGLM
                assumeStdFlag( (leftv)ih );
                if ( fglmzero( sourceRing, sourceIdeal, destRing, destIdeal, FALSE, (currRing->qideal != NULL) ) == FALSE )
                    state= FglmNotReduced;
            }
        } else state= FglmNoIdeal;
    }
    if ( currRing != destRing )
        rChangeCurrRing( destRing );
    switch (state)
    {
        case FglmOk:
            if ( currRing->qideal != NULL ) fglmUpdateresult( destIdeal );
            break;
        case FglmHasOne:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        case FglmIncompatibleRings:
            WerrorS( "source ring and current ring are incompatible" );
            destIdeal= NULL;
            break;
        case FglmNoIdeal:
            Werror( "Can't find ideal %s in source ring", second->Name() );
            destIdeal= NULL;
            break;
        case FglmNotZeroDim:
            Werror( "The ideal %s has to be 0-dimensional", second->Name() );
            destIdeal= NULL;
            break;
        case FglmNotReduced:
            Werror( "The ideal %s has to be given by a reduced SB", second->Name() );
            destIdeal= NULL;
            break;
        default:
            destIdeal= idInit(1,1);
    }
 
    result->rtyp = IDEAL_CMD;
    result->data= (void *)destIdeal;
    setFlag( result, FLAG_STD );
    return (state != FglmOk);
}

fglmQuot()

ideal fglmQuot	(	ideal	first,
		poly	second
	)

Definition at line 350 of file fglm.cc.

{
    FglmState state = FglmOk;
 
    ideal sourceIdeal = first;
    poly quot = second;
    ideal destIdeal = NULL;
 
    state = fglmIdealcheck( sourceIdeal );
    if ( state == FglmOk )
    {
      if ( quot == NULL ) state= FglmPolyIsZero;
      else if ( pIsConstant( quot ) ) state= FglmPolyIsOne;
    }
 
    if ( state == FglmOk )
    {
      if ( fglmquot( sourceIdeal, quot, destIdeal ) == FALSE )
        state= FglmNotReduced;
    }
 
    switch (state)
    {
        case FglmOk:
            break;
        case FglmHasOne:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        case FglmNotZeroDim:
            WerrorS( "The ideal has to be 0-dimensional" );
            destIdeal= idInit(1,1);
            break;
        case FglmNotReduced:
            WerrorS( "The poly has to be reduced" );
            destIdeal= idInit(1,1);
            break;
        case FglmPolyIsOne:
            int k;
            destIdeal= idInit( IDELEMS(sourceIdeal), 1 );
            for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
              (destIdeal->m)[k]= pCopy( (sourceIdeal->m)[k] );
            state= FglmOk;
            break;
        case FglmPolyIsZero:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        default:
            destIdeal= idInit(1,1);
    }
 
    return destIdeal;
}

fglmQuotProc()

BOOLEAN fglmQuotProc	(	leftv	result,
		leftv	first,
		leftv	second
	)

Definition at line 411 of file fglm.cc.

{
    FglmState state = FglmOk;
 
    //    STICKYPROT("quotstart\n");
    ideal sourceIdeal = (ideal)first->Data();
    poly quot = (poly)second->Data();
    ideal destIdeal = NULL;
 
    state = fglmIdealcheck( sourceIdeal );
    if ( state == FglmOk )
    {
      if ( quot == NULL ) state= FglmPolyIsZero;
      else if ( pIsConstant( quot ) ) state= FglmPolyIsOne;
    }
 
    if ( state == FglmOk )
    {
      assumeStdFlag( first );
      if ( fglmquot( sourceIdeal, quot, destIdeal ) == FALSE )
        state= FglmNotReduced;
    }
 
    switch (state)
    {
        case FglmOk:
            break;
        case FglmHasOne:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        case FglmNotZeroDim:
            Werror( "The ideal %s has to be 0-dimensional", first->Name() );
            destIdeal= NULL;
            break;
        case FglmNotReduced:
            Werror( "The poly %s has to be reduced", second->Name() );
            destIdeal= NULL;
            break;
        case FglmPolyIsOne:
            int k;
            destIdeal= idInit( IDELEMS(sourceIdeal), 1 );
            for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
              (destIdeal->m)[k]= pCopy( (sourceIdeal->m)[k] );
            state= FglmOk;
            break;
        case FglmPolyIsZero:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        default:
            destIdeal= idInit(1,1);
    }
 
    result->rtyp = IDEAL_CMD;
    result->data= (void *)destIdeal;
    setFlag( result, FLAG_STD );
    // STICKYPROT("quotend\n");
    return (state != FglmOk);
} // fglmQuotProt

findUni()

ideal findUni

(

ideal

first

)

Definition at line 474 of file fglm.cc.

{
    ideal sourceIdeal;
    ideal destIdeal = NULL;
    FglmState state;
 
    sourceIdeal = first;
 
    state= fglmIdealcheck( sourceIdeal );
    if ( state == FglmOk )
    {
      // check for special cases: if the input contains
      // univariate polys, try to reduce the problem
      int i,k;
      int count=0;
      BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
      for ( k= IDELEMS( sourceIdeal ) - 1; k >= 0; k-- )
      {
        if((i=pIsUnivariate(sourceIdeal->m[k]))>0)
        {
          if (purePowers[i-1]==0)
          {
            purePowers[i-1]=k;
            count++;
            if (count==currRing->N) break;
          }
        }
      }
      if (count==currRing->N)
      {
        destIdeal=idInit(currRing->N,1);
        for(k=currRing->N-1; k>=0; k--) destIdeal->m[k]=pCopy(sourceIdeal->m[purePowers[k]]);
      }
      omFreeSize((ADDRESS)purePowers, currRing->N*sizeof( BOOLEAN ) );
      if (destIdeal!=NULL)
            state = FglmOk;
      else if ( FindUnivariateWrapper( sourceIdeal, destIdeal ) == FALSE )
            state = FglmNotReduced;
    }
    switch (state)
    {
        case FglmOk:
            break;
        case FglmHasOne:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        case FglmNotZeroDim:
            WerrorS( "The ideal has to be 0-dimensional" );
            destIdeal= idInit(1,1);
            break;
        case FglmNotReduced:
            Werror( "The ideal has to be reduced" );
            destIdeal= idInit(1,1);
            break;
        default:
            destIdeal= idInit(1,1);
    }
 
    return destIdeal;
}

findUniProc()

BOOLEAN findUniProc	(	leftv	result,
		leftv	first
	)

Definition at line 541 of file fglm.cc.

{
    ideal sourceIdeal;
    ideal destIdeal = NULL;
    FglmState state;
 
    sourceIdeal = (ideal)first->Data();
 
    assumeStdFlag( first );
    state= fglmIdealcheck( sourceIdeal );
    if ( state == FglmOk )
    {
      // check for special cases: if the input contains
      // univariate polys, try to reduce the problem
      int i,k;
      int count=0;
      BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
      for ( k= IDELEMS( sourceIdeal ) - 1; k >= 0; k-- )
      {
        if((i=pIsUnivariate(sourceIdeal->m[k]))>0)
        {
          if (purePowers[i-1]==0)
          {
            purePowers[i-1]=k;
            count++;
            if (count==currRing->N) break;
          }
        }
      }
      if (count==currRing->N)
      {
        destIdeal=idInit(currRing->N,1);
        for(k=currRing->N-1; k>=0; k--) destIdeal->m[k]=pCopy(sourceIdeal->m[purePowers[k]]);
      }
      omFreeSize((ADDRESS)purePowers, currRing->N*sizeof( BOOLEAN ) );
      if (destIdeal!=NULL)
            state = FglmOk;
      else if ( FindUnivariateWrapper( sourceIdeal, destIdeal ) == FALSE )
            state = FglmNotReduced;
    }
    switch (state)
    {
        case FglmOk:
            break;
        case FglmHasOne:
            destIdeal= idInit(1,1);
            (destIdeal->m)[0]= pOne();
            state= FglmOk;
            break;
        case FglmNotZeroDim:
            Werror( "The ideal %s has to be 0-dimensional", first->Name() );
            destIdeal= NULL;
            break;
        case FglmNotReduced:
            Werror( "The ideal %s has to be reduced", first->Name() );
            destIdeal= NULL;
            break;
        default:
            destIdeal= idInit(1,1);
    }
 
    result->rtyp = IDEAL_CMD;
    result->data= (void *)destIdeal;
 
    return FALSE;
}

FindUnivariateWrapper()

BOOLEAN FindUnivariateWrapper	(	ideal	source,
		ideal &	dest
	)

Definition at line 1236 of file fglmzero.cc.

{
    BOOLEAN fglmok;
 
    idealFunctionals L( 100, (currRing->N) );
    fglmok = CalculateFunctionals( source, L );
    if ( fglmok == TRUE ) {
        destIdeal= FindUnivariatePolys( L );
        return TRUE;
    }
    else
        return FALSE;
}