Changeset 5812c69 in git for Singular/fglmzero.cc


Ignore:
Timestamp:
Sep 24, 1998, 11:59:51 AM (26 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '4a9821a93ffdc22a6696668bd4f6b8c9de3e6c5f')
Children:
56c52a7879fbc6de62cefba1da86b2edf2aadd4c
Parents:
073d2edeb03013a5c6ed0913687b024305a1427d
Message:
cosmetic changes


git-svn-id: file:///usr/local/Singular/svn/trunk@2517 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/fglmzero.cc

    r073d2e r5812c69  
    11// emacs edit mode for this file is -*- C++ -*-
    2 // $Id: fglmzero.cc,v 1.17 1998-06-03 15:25:20 obachman Exp $
     2// $Id: fglmzero.cc,v 1.18 1998-09-24 09:59:40 Singular Exp $
    33
    44/****************************************
    55*  Computer Algebra System SINGULAR     *
    66****************************************/
    7 /* 
     7/*
    88* ABSTRACT - The FGLM-Algorithm
    99*   Implementation of the fglm algorithm for 0-dimensional ideals,
    1010*   based on an idea by Faugere/Gianni/Lazard and Mora.
    11 *   The procedure CalculateFunctionals calculates the functionals 
     11*   The procedure CalculateFunctionals calculates the functionals
    1212*   which define the given ideal in the source ring. They build the
    1313*   input for GroebnerViaFunctionals, which defines the reduced
    … …  
    3535#include "fglmgauss.h"
    3636// assumes, that NOSTREAMIO is set in factoryconf.h, which is included
    37 // by templates/list.h. 
     37// by templates/list.h.
    3838#include <templates/ftmpl_list.h>
    3939#define PROT(msg)
    … …  
    4646// internal Version: 1.3.1.12
    4747// ============================================================
    48 //!      The idealFunctionals 
     48//!      The idealFunctionals
    4949// ============================================================
    5050
    … …  
    7171    int * currentSize;
    7272    matHeader ** func;
    73     matHeader * grow( int var ); 
     73    matHeader * grow( int var );
    7474public:
    7575    idealFunctionals( int blockSize, int numFuncs );
    7676    ~idealFunctionals();
    7777
    78     int dimen() const { fglmASSERT( _size>0, "called to early"); return _size; } 
     78    int dimen() const { fglmASSERT( _size>0, "called to early"); return _size; }
    7979    void endofConstruction();
    8080    void map( ring source );
    … …  
    8585};
    8686
    87 idealFunctionals::idealFunctionals( int blockSize, int numFuncs ) 
     87idealFunctionals::idealFunctionals( int blockSize, int numFuncs )
    8888{
    8989    int k;
    … …  
    9494
    9595    currentSize= (int *)Alloc( _nfunc*sizeof( int ) );
    96     for ( k= _nfunc-1; k >= 0; k-- ) 
    97         currentSize[k]= 0;
     96    for ( k= _nfunc-1; k >= 0; k-- )
     97        currentSize[k]= 0;
    9898
    9999    func= (matHeader **)Alloc( _nfunc*sizeof( matHeader * ) );
    100     for ( k= _nfunc-1; k >= 0; k-- ) 
    101         func[k]= (matHeader *)Alloc( _max*sizeof( matHeader ) );
     100    for ( k= _nfunc-1; k >= 0; k-- )
     101        func[k]= (matHeader *)Alloc( _max*sizeof( matHeader ) );
    102102}
    103103
    … …  
    110110    matElem * elemp;
    111111    for ( k= _nfunc-1; k >= 0; k-- ) {
    112         for ( l= _size-1, colp= func[k]; l >= 0; l--, colp++ ) {
    113             if ( ( colp->owner == TRUE ) && ( colp->size > 0 ) ) {
    114                 for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ )
    115                     nDelete( & elemp->elem );
    116                 Free( (ADDRESS)colp->elems, colp->size*sizeof( matElem ) );
    117             }
    118         }
    119         Free( (ADDRESS)func[k], _max*sizeof( matHeader ) );
     112        for ( l= _size-1, colp= func[k]; l >= 0; l--, colp++ ) {
     113            if ( ( colp->owner == TRUE ) && ( colp->size > 0 ) ) {
     114                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ )
     115                    nDelete( & elemp->elem );
     116                Free( (ADDRESS)colp->elems, colp->size*sizeof( matElem ) );
     117            }
     118        }
     119        Free( (ADDRESS)func[k], _max*sizeof( matHeader ) );
    120120    }
    121121    Free( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
    … …  
    124124
    125125void
    126 idealFunctionals::endofConstruction() 
     126idealFunctionals::endofConstruction()
    127127{
    128128    _size= currentSize[0];
    … …  
    130130
    131131void
    132 idealFunctionals::map( ring source ) 
     132idealFunctionals::map( ring source )
    133133{
    134134    // maps from ring source to currentRing.
    … …  
    141141    maFindPerm( source->names, source->N, NULL, 0, currRing->names, currRing->N, NULL, 0, perm, NULL );
    142142    nSetMap( source->ch, source->parameter, source->P, source->minpoly );
    143    
     143
    144144    matHeader ** temp = (matHeader **)Alloc( _nfunc*sizeof( matHeader * ));
    145145    for ( var= 0; var < _nfunc; var ++ ) {
    146         for ( col= 0, colp= func[var]; col < _size; col++, colp++ ) {
    147             if ( colp->owner == TRUE ) {
    148                 for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ ) {
    149                     newelem= nMap( elemp->elem );
    150                     nDelete( & elemp->elem );
    151                     elemp->elem= newelem;
    152                 }
    153             }
    154         }
    155         temp[ perm[var+1]-1 ]= func[var];
     146        for ( col= 0, colp= func[var]; col < _size; col++, colp++ ) {
     147            if ( colp->owner == TRUE ) {
     148                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ ) {
     149                    newelem= nMap( elemp->elem );
     150                    nDelete( & elemp->elem );
     151                    elemp->elem= newelem;
     152                }
     153            }
     154        }
     155        temp[ perm[var+1]-1 ]= func[var];
    156156    }
    157157    Free( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
    … …  
    161161
    162162matHeader *
    163 idealFunctionals::grow( int var ) 
     163idealFunctionals::grow( int var )
    164164{
    165165    if ( currentSize[var-1] == _max ) {
    166         int k;
    167         for ( k= _nfunc; k > 0; k-- )
    168             func[k-1]= (matHeader *)ReAlloc( func[k-1], _max*sizeof( matHeader ), (_max + _block)*sizeof( matHeader ) );
    169         _max+= _block;
     166        int k;
     167        for ( k= _nfunc; k > 0; k-- )
     168            func[k-1]= (matHeader *)ReAlloc( func[k-1], _max*sizeof( matHeader ), (_max + _block)*sizeof( matHeader ) );
     169        _max+= _block;
    170170    }
    171171    currentSize[var-1]++;
    172     return func[var-1] + currentSize[var-1] - 1; 
     172    return func[var-1] + currentSize[var-1] - 1;
    173173}
    174174
    … …  
    183183    elems->elem= nInit( 1 );
    184184    for ( k= divisors[0]; k > 0; k-- ) {
    185         fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
    186         matHeader * colp = grow( divisors[k] );
    187         colp->size= 1;
    188         colp->elems= elems;
    189         colp->owner= owner;
    190         owner= FALSE;
    191     }
    192 }
    193 
    194    
     185        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
     186        matHeader * colp = grow( divisors[k] );
     187        colp->size= 1;
     188        colp->elems= elems;
     189        colp->owner= owner;
     190        owner= FALSE;
     191    }
     192}
     193
     194
    195195void
    196196idealFunctionals::insertCols( int * divisors, const fglmVector to )
    … …  
    204204    BOOLEAN owner = TRUE;
    205205    if ( numElems > 0 ) {
    206         elems= (matElem *)Alloc( numElems * sizeof( matElem ) );
    207         for ( k= 1, l= 1, elemp= elems; k <= numElems; k++, elemp++ ) {
    208             while ( nIsZero( to.getconstelem(l) ) ) l++;
    209             elemp->row= l;
    210             elemp->elem= nCopy( to.getconstelem( l ) );
    211             l++; // hochzaehlen, damit wir nicht noch einmal die gleiche Stelle testen
    212         }
     206        elems= (matElem *)Alloc( numElems * sizeof( matElem ) );
     207        for ( k= 1, l= 1, elemp= elems; k <= numElems; k++, elemp++ ) {
     208            while ( nIsZero( to.getconstelem(l) ) ) l++;
     209            elemp->row= l;
     210            elemp->elem= nCopy( to.getconstelem( l ) );
     211            l++; // hochzaehlen, damit wir nicht noch einmal die gleiche Stelle testen
     212        }
    213213    }
    214214    else
    215         elems= NULL;
     215        elems= NULL;
    216216    for ( k= divisors[0]; k > 0; k-- ) {
    217         fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
    218         matHeader * colp = grow( divisors[k] );
    219         colp->size= numElems;
    220         colp->elems= elems;
    221         colp->owner= owner;
    222         owner= FALSE;
     217        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
     218        matHeader * colp = grow( divisors[k] );
     219        colp->size= numElems;
     220        colp->elems= elems;
     221        colp->owner= owner;
     222        owner= FALSE;
    223223    }
    224224}
    … …  
    236236    fglmASSERT( currentSize[var-1]+1 >= vsize, "wrong v.size()" );
    237237    for ( k= 1, colp= func[var-1]; k <= vsize; k++, colp++ ) {
    238         factor= v.getconstelem( k );
    239         if ( ! nIsZero( factor ) ) {
    240             for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
    241                 temp= nMult( factor, elemp->elem );
    242                 number newelem= nAdd( result.getconstelem( elemp->row ), temp );
    243                 nDelete( & temp );
    244                 nNormalize( newelem );
    245                 result.setelem( elemp->row, newelem );
    246             }   
    247         }
     238        factor= v.getconstelem( k );
     239        if ( ! nIsZero( factor ) ) {
     240            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
     241                temp= nMult( factor, elemp->elem );
     242                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
     243                nDelete( & temp );
     244                nNormalize( newelem );
     245                result.setelem( elemp->row, newelem );
     246            }
     247        }
    248248    }
    249249    return result;
    … …  
    260260    int k, l;
    261261    for ( k= 1, colp= func[var-1]; k <= _size; k++, colp++ ) {
    262         factor= v.getconstelem( k );
    263         if ( ! nIsZero( factor ) ) {
    264             for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
    265                 temp= nMult( factor, elemp->elem );
    266                 number newelem= nAdd( result.getconstelem( elemp->row ), temp );
    267                 nDelete( & temp );
    268                 nNormalize( newelem );
    269                 result.setelem( elemp->row, newelem );
    270             }
    271         }
     262        factor= v.getconstelem( k );
     263        if ( ! nIsZero( factor ) ) {
     264            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
     265                temp= nMult( factor, elemp->elem );
     266                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
     267                nDelete( & temp );
     268                nNormalize( newelem );
     269                result.setelem( elemp->row, newelem );
     270            }
     271        }
    272272    }
    273273    return result;
    … …  
    275275
    276276// ============================================================
    277 //!      The old basis 
     277//!      The old basis
    278278// ============================================================
    279279
    … …  
    283283//      the basis when the normalForm was computed.
    284284//     monom gets deleted when borderElem comes out of scope.
    285 class borderElem 
     285class borderElem
    286286{
    287287public:
    … …  
    292292    ~borderElem() { pDelete1( &monom ); }
    293293#ifndef HAVE_EXPLICIT_CONSTR
    294     void insertElem( poly p, fglmVector n ) 
     294    void insertElem( poly p, fglmVector n )
    295295    {
    296         monom= p;
    297         nf= n;
     296        monom= p;
     297        nf= n;
    298298    }
    299299#endif
    … …  
    303303//     The declaration of class fglmSelem is found in fglm.h
    304304
    305 fglmSelem::fglmSelem( poly p, int var ) : numVars( 0 ), monom( p ) 
    306 {
    307     for ( int k = pVariables; k > 0; k-- ) 
    308         if ( pGetExp( monom, k ) > 0 )
    309             numVars++;
     305fglmSelem::fglmSelem( poly p, int var ) : numVars( 0 ), monom( p )
     306{
     307    for ( int k = pVariables; k > 0; k-- )
     308        if ( pGetExp( monom, k ) > 0 )
     309            numVars++;
    310310    divisors= (int *)Alloc( (numVars+1)*sizeof( int ) );
    311311    divisors[0]= 0;
    … …  
    313313}
    314314
    315 void 
     315void
    316316fglmSelem::cleanup()
    317317{
    … …  
    355355};
    356356
    357 fglmSdata::fglmSdata( const ideal thisIdeal ) 
     357fglmSdata::fglmSdata( const ideal thisIdeal )
    358358{
    359359    // An dieser Stelle kann die BlockSize ( =BS ) noch sinnvoller berechnet
    … …  
    365365    basisMax= basisBS;
    366366    basisSize= 0;
    367     basis= (polyset)Alloc( basisMax*sizeof( poly ) ); 
     367    basis= (polyset)Alloc( basisMax*sizeof( poly ) );
    368368
    369369    borderBS= 100;
    … …  
    382382{
    383383    for ( int k = basisSize; k > 0; k-- )
    384         pDelete1( basis + k );  //. rem: basis runs from basis[1]..basis[basisSize]
     384        pDelete1( basis + k );  //. rem: basis runs from basis[1]..basis[basisSize]
    385385    Free( (ADDRESS)basis, basisMax*sizeof( poly ) );
    386386#ifndef HAVE_EXPLICIT_CONSTR
    … …  
    388388#else
    389389    for ( int l = borderSize; l > 0; l-- )
    390         // rem: the polys of borderElem are deleted via ~borderElem()
    391         border[l].~borderElem();
     390        // rem: the polys of borderElem are deleted via ~borderElem()
     391        border[l].~borderElem();
    392392    Free( (ADDRESS)border, borderMax*sizeof( borderElem ) );
    393393#endif
    394394}
    395395
    396 //     Inserts poly p without copying into basis, reAllocs Memory if necessary, 
     396//     Inserts poly p without copying into basis, reAllocs Memory if necessary,
    397397//      increases basisSize and returns the new basisSize.
    398398//     Remember: The elements of basis are deleted via pDelete in ~fglmSdata!
    399399//     Sets m= NULL to indicate that now basis is ow(e?)ing the poly.
    400400int
    401 fglmSdata::newBasisElem( poly & m ) 
     401fglmSdata::newBasisElem( poly & m )
    402402{
    403403    basisSize++;
    404404    if ( basisSize == basisMax ) {
    405         basis= (polyset)ReAlloc( basis, basisMax*sizeof( poly ), (basisMax + basisBS)*sizeof( poly ) );
    406         basisMax+= basisBS;
     405        basis= (polyset)ReAlloc( basis, basisMax*sizeof( poly ), (basisMax + basisBS)*sizeof( poly ) );
     406        basisMax+= basisBS;
    407407    }
    408408    basis[basisSize]= m;
    … …  
    411411}
    412412
    413 //     Inserts poly p and fglmvector v without copying into border, reAllocs Memory 
     413//     Inserts poly p and fglmvector v without copying into border, reAllocs Memory
    414414//      if necessary, and increases borderSize.
    415415//     Remember: The poly of border is deleted via ~borderElem in ~fglmSdata!
    … …  
    421421    if ( borderSize == borderMax ) {
    422422#ifndef HAVE_EXPLICIT_CONSTR
    423         borderElem * tempborder = new borderElem[ borderMax+borderBS ];
    424         for ( int k = 0; k < borderMax; k++ ) {
    425             tempborder[k]= border[k];
    426             border[k].insertElem( NULL, fglmVector() );
    427         }
    428         delete [] border;
    429         border= tempborder;
     423        borderElem * tempborder = new borderElem[ borderMax+borderBS ];
     424        for ( int k = 0; k < borderMax; k++ ) {
     425            tempborder[k]= border[k];
     426            border[k].insertElem( NULL, fglmVector() );
     427        }
     428        delete [] border;
     429        border= tempborder;
    430430#else
    431         border= (borderElem *)ReAlloc( border, borderMax*sizeof( borderElem ), (borderMax + borderBS)*sizeof( borderElem ) );
     431        border= (borderElem *)ReAlloc( border, borderMax*sizeof( borderElem ), (borderMax + borderBS)*sizeof( borderElem ) );
    432432#endif
    433         borderMax+= borderBS;
     433        borderMax+= borderBS;
    434434    }
    435435#ifndef HAVE_EXPLICIT_CONSTR
    … …  
    449449}
    450450
    451 //     Multiplies basis[basisSize] with all ringvariables and inserts the new monomials 
     451//     Multiplies basis[basisSize] with all ringvariables and inserts the new monomials
    452452//      into the list of candidates, according to the given order. If a monomial already
    453 //      exists, then "insertions" and "divisors" are updated. 
    454 //     Assumes that ringvar(k) < ringvar(l) for k > l 
     453//      exists, then "insertions" and "divisors" are updated.
     454//     Assumes that ringvar(k) < ringvar(l) for k > l
    455455void
    456456fglmSdata::updateCandidates()
    … …  
    464464    int state = 0;
    465465    while ( k >= 1 ) {
    466         newmonom = pCopy( m ); 
    467         pIncrExp( newmonom, k );
    468         pSetm( newmonom );
    469         done= FALSE;
    470         while ( list.hasItem() && (done == FALSE) ) {
    471             if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
    472                 list++;
    473             else done= TRUE;
    474         }
    475         if ( done == FALSE ) {
    476             nlist.append( fglmSelem( newmonom, k ) );
    477             break;
    478         }
    479         if ( state == 0 ) {
    480             list.getItem().newDivisor( k );
    481             pDelete1( &newmonom );
    482         }
    483         else {
    484             list.insert( fglmSelem( newmonom, k ) );
    485         }
    486         k--;
     466        newmonom = pCopy( m );
     467        pIncrExp( newmonom, k );
     468        pSetm( newmonom );
     469        done= FALSE;
     470        while ( list.hasItem() && (done == FALSE) ) {
     471            if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
     472                list++;
     473            else done= TRUE;
     474        }
     475        if ( done == FALSE ) {
     476            nlist.append( fglmSelem( newmonom, k ) );
     477            break;
     478        }
     479        if ( state == 0 ) {
     480            list.getItem().newDivisor( k );
     481            pDelete1( &newmonom );
     482        }
     483        else {
     484            list.insert( fglmSelem( newmonom, k ) );
     485        }
     486        k--;
    487487    }
    488488    while ( --k >= 1 ) {
    489         newmonom= pCopy( m ); // HIER
    490         pIncrExp( newmonom, k );
    491         pSetm( newmonom );
    492         nlist.append( fglmSelem( newmonom, k ) );
     489        newmonom= pCopy( m ); // HIER
     490        pIncrExp( newmonom, k );
     491        pSetm( newmonom );
     492        nlist.append( fglmSelem( newmonom, k ) );
    493493    }
    494494}
    … …  
    498498//      coefficients.)
    499499int
    500 fglmSdata::getEdgeNumber( const poly m ) const 
    501 {
    502     for ( int k = idelems; k > 0; k-- ) 
    503         if ( pEqual( m, (theIdeal->m)[k-1] ) )
    504             return k;
     500fglmSdata::getEdgeNumber( const poly m ) const
     501{
     502    for ( int k = idelems; k > 0; k-- )
     503        if ( pEqual( m, (theIdeal->m)[k-1] ) )
     504            return k;
    505505    return 0;
    506506}
    507507
    508 //     Returns the fglmVector v, s.t. 
     508//     Returns the fglmVector v, s.t.
    509509//        p = v[1]*basis(1) + .. + v[basisSize]*basis(basisSize)
    510510//     So the size of v depends on the current size of the basis.
    … …  
    512512//      smaller than basis[basisSize] and that basis[k] < basis[l] for k < l.
    513513fglmVector
    514 fglmSdata::getVectorRep( const poly p ) 
     514fglmSdata::getVectorRep( const poly p )
    515515{
    516516    fglmVector temp( basisSize );
    … …  
    518518    int num = basisSize;
    519519    while ( m != NULL ) {
    520         int comp = pComp( m, basis[num] );
    521         if ( comp == 0 ) {
    522             fglmASSERT( num > 0, "Error(1) in fglmSdata::getVectorRep" );
    523             number newelem = nCopy( pGetCoeff( m ) );
    524             temp.setelem( num, newelem );
    525             num--;
    526             pIter( m );
    527         }
    528         else { 
    529             if ( comp < 0 ) {
    530                 num--;
    531             }
    532             else {
    533                 // This is the place where we can detect if the sourceIdeal
    534                 // is not reduced. In this case m is not in basis[]. Since basis[]
    535                 // is ordered this is then and only then the case, if basis[i]<m
    536                 // and basis[j]>m for all j>i
    537                 _state= FALSE;
    538                 return temp;
    539             }
    540         }
     520        int comp = pComp( m, basis[num] );
     521        if ( comp == 0 ) {
     522            fglmASSERT( num > 0, "Error(1) in fglmSdata::getVectorRep" );
     523            number newelem = nCopy( pGetCoeff( m ) );
     524            temp.setelem( num, newelem );
     525            num--;
     526            pIter( m );
     527        }
     528        else {
     529            if ( comp < 0 ) {
     530                num--;
     531            }
     532            else {
     533                // This is the place where we can detect if the sourceIdeal
     534                // is not reduced. In this case m is not in basis[]. Since basis[]
     535                // is ordered this is then and only then the case, if basis[i]<m
     536                // and basis[j]>m for all j>i
     537                _state= FALSE;
     538                return temp;
     539            }
     540        }
    541541    }
    542542    return temp;
    … …  
    545545//     Searches through the border for a monomoial bm which devides m and returns
    546546//      its normalform in vector representation.
    547 //     var contains the number of the variable v, s.t. bm = m * v 
     547//     var contains the number of the variable v, s.t. bm = m * v
    548548fglmVector
    549549fglmSdata::getBorderDiv( const poly m, int & var ) const
    … …  
    551551//     int num2 = borderSize;
    552552//     while ( num2 > 0 ) {
    553 //      poly temp = border[num2].monom;
    554 //      if ( pDivisibleBy( temp, m ) ) {
    555 //          poly divisor = pDivideM( m, temp );
    556 //          int var = pIsPurePower( divisor );
    557 //          if ( (var != 0) && (pGetCoeff( divisor, var ) == 1) ) {
    558 //              Print( "poly %s divides poly %s", pString( temp ), pString( m ) );
    559 //          }
    560 //      }
    561 //      num2--;
     553//         poly temp = border[num2].monom;
     554//         if ( pDivisibleBy( temp, m ) ) {
     555//             poly divisor = pDivideM( m, temp );
     556//             int var = pIsPurePower( divisor );
     557//             if ( (var != 0) && (pGetCoeff( divisor, var ) == 1) ) {
     558//                 Print( "poly %s divides poly %s", pString( temp ), pString( m ) );
     559//             }
     560//         }
     561//         num2--;
    562562//     }
    563563    int num = borderSize;
    564564    while ( num > 0 ) {
    565         poly temp = border[num].monom;
    566         if ( pDivisibleBy( temp, m ) ) {
    567             var = pVariables;
    568             while ( var > 0 ) {
    569                 if ( (pGetExp( m, var ) - pGetExp( temp, var )) == 1 )
    570                     return border[num].nf;
    571                 var--;
    572             }
    573         }
    574         num--;
     565        poly temp = border[num].monom;
     566        if ( pDivisibleBy( temp, m ) ) {
     567            var = pVariables;
     568            while ( var > 0 ) {
     569                if ( (pGetExp( m, var ) - pGetExp( temp, var )) == 1 )
     570                    return border[num].nf;
     571                var--;
     572            }
     573        }
     574        num--;
    575575    }
    576576    return fglmVector();
    577577}
    578578
    579 //     Calculates the defining Functionals for the ideal "theIdeal" and 
     579//     Calculates the defining Functionals for the ideal "theIdeal" and
    580580//     returns them in "l".
    581581//     The ideal has to be zero-dimensional and reduced and has to be a
    582582//     real subset of the polynomal ring.
    583 //     In any case it has to be zero-dimensional and minimal (check this 
     583//     In any case it has to be zero-dimensional and minimal (check this
    584584//      via fglmIdealcheck). Any minimal but not reduced ideal is detected.
    585585//      In this case it returns FglmNotReduced.
    … …  
    600600    STICKYPROT(".");
    601601    while ( data.candidatesLeft() == TRUE ) {
    602         fglmSelem candidate = data.nextCandidate();
    603         if ( candidate.isBasisOrEdge() == TRUE ) {
    604             int edge = data.getEdgeNumber( candidate.monom );
    605             if ( edge != 0 ) {
    606                 // now candidate is an edge, i.e. we know its normalform:
    607                 // NF(p) = - ( tail(p)/LC(p) )
    608                 poly nf = data.getSpanPoly( edge );
    609                 pNorm( nf );
    610                 pDelete1( &nf );  //. deletes the leadingmonomial
    611                 nf= pNeg( nf );
    612                 fglmVector nfv = data.getVectorRep( nf );
    613                 l.insertCols( candidate.divisors, nfv );
    614                 data.newBorderElem( candidate.monom, nfv );
    615                 pDelete( &nf );
    616                 STICKYPROT( "+" );
    617             }
    618             else {
    619                 int basis= data.newBasisElem( candidate.monom );
    620                 data.updateCandidates();
    621                 l.insertCols( candidate.divisors, basis );
    622                 STICKYPROT( "." );
    623             }
    624         }
    625         else {
    626             int var = 0;
    627             fglmVector temp = data.getBorderDiv( candidate.monom, var );
    628             fglmASSERT( var > 0, "this should never happen" );
    629             fglmVector nfv = l.addCols( var, data.getBasisSize(), temp );
    630             data.newBorderElem( candidate.monom, nfv );
    631             l.insertCols( candidate.divisors, nfv );
    632             STICKYPROT( "-" );
    633         }
    634         candidate.cleanup();
     602        fglmSelem candidate = data.nextCandidate();
     603        if ( candidate.isBasisOrEdge() == TRUE ) {
     604            int edge = data.getEdgeNumber( candidate.monom );
     605            if ( edge != 0 ) {
     606                // now candidate is an edge, i.e. we know its normalform:
     607                // NF(p) = - ( tail(p)/LC(p) )
     608                poly nf = data.getSpanPoly( edge );
     609                pNorm( nf );
     610                pDelete1( &nf );  //. deletes the leadingmonomial
     611                nf= pNeg( nf );
     612                fglmVector nfv = data.getVectorRep( nf );
     613                l.insertCols( candidate.divisors, nfv );
     614                data.newBorderElem( candidate.monom, nfv );
     615                pDelete( &nf );
     616                STICKYPROT( "+" );
     617            }
     618            else {
     619                int basis= data.newBasisElem( candidate.monom );
     620                data.updateCandidates();
     621                l.insertCols( candidate.divisors, basis );
     622                STICKYPROT( "." );
     623            }
     624        }
     625        else {
     626            int var = 0;
     627            fglmVector temp = data.getBorderDiv( candidate.monom, var );
     628            fglmASSERT( var > 0, "this should never happen" );
     629            fglmVector nfv = l.addCols( var, data.getBasisSize(), temp );
     630            data.newBorderElem( candidate.monom, nfv );
     631            l.insertCols( candidate.divisors, nfv );
     632            STICKYPROT( "-" );
     633        }
     634        candidate.cleanup();
    635635    } //. while ( data.candidatesLeft() == TRUE )
    636636    l.endofConstruction();
    … …  
    645645//     The declaration of class fglmDelem is found in fglm.h
    646646
    647 fglmDelem::fglmDelem( poly & m, fglmVector mv, int v ) : insertions( 0 ), v( mv ), var( v ) 
    648 {
    649     monom= m; 
     647fglmDelem::fglmDelem( poly & m, fglmVector mv, int v ) : insertions( 0 ), v( mv ), var( v )
     648{
     649    monom= m;
    650650    m= NULL;
    651651    for ( int k = pVariables; k > 0; k-- )
    652         if ( pGetExp( monom, k ) > 0 )
    653             insertions++;
     652        if ( pGetExp( monom, k ) > 0 )
     653            insertions++;
    654654    // Wir gehen davon aus, dass ein fglmDelem direkt bei der Erzeugung
    655655    // auch in eine Liste eingefuegt wird. Daher wird hier automatisch
    … …  
    662662{
    663663    if ( monom != NULL ) {
    664         pDelete1( &monom );
     664        pDelete1( &monom );
    665665    }
    666666}
    … …  
    679679    oldGaussElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac ) : v( newv ), p( newp ), pdenom( newpdenom ), fac( newfac )
    680680    {
    681         newpdenom= NULL;
    682         newfac= NULL;
     681        newpdenom= NULL;
     682        newfac= NULL;
    683683    }
    684684    ~oldGaussElem();
    685685#ifndef HAVE_EXPLICIT_CONSTR
    686     void insertElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac ) 
     686    void insertElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac )
    687687    {
    688         v= newv;
    689         p= newp;
    690         pdenom= newpdenom;
    691         fac= newfac;
    692         newpdenom= NULL;
    693         newfac= NULL;
     688        v= newv;
     689        p= newp;
     690        pdenom= newpdenom;
     691        fac= newfac;
     692        newpdenom= NULL;
     693        newfac= NULL;
    694694    }
    695695#endif
    … …  
    703703
    704704
    705 class fglmDdata 
     705class fglmDdata
    706706{
    707707private:
    … …  
    712712    int basisSize;  //. the CURRENT basisSize, i.e. basisSize <= dimen
    713713    polyset basis;  // [1]..[dimen]. The monoms of the new Vectorspace-basis
    714    
     714
    715715    int groebnerBS;
    716716    int groebnerSize;
    … …  
    729729    void newGroebnerPoly( fglmVector & v, poly & p );
    730730    void gaussreduce( fglmVector & v, fglmVector & p, number & denom );
    731     ideal buildIdeal() 
     731    ideal buildIdeal()
    732732    {
    733         idSkipZeroes( destId );
    734         return destId;
     733        idSkipZeroes( destId );
     734        return destId;
    735735    }
    736736};
    … …  
    763763    delete [] gauss;
    764764#else
    765     for ( k= dimen; k > 0; k-- ) 
    766         gauss[k].~oldGaussElem();
     765    for ( k= dimen; k > 0; k-- )
     766        gauss[k].~oldGaussElem();
    767767    Free( (ADDRESS)gauss, (dimen+1)*sizeof( oldGaussElem ) );
    768768#endif
    … …  
    771771    //. Remember: There is no poly in basis[0], thus k > 0
    772772    for ( k= dimen; k > 0; k-- )
    773         pDelete1( basis + k );
     773        pDelete1( basis + k );
    774774    Free( (ADDRESS)basis, (dimen+1)*sizeof( poly ) );
    775775}
    776776
    777777fglmDelem
    778 fglmDdata::nextCandidate() 
     778fglmDdata::nextCandidate()
    779779{
    780780    fglmDelem result = nlist.getFirst();
    … …  
    783783}
    784784
    785 void 
     785void
    786786fglmDdata::newBasisElem( poly & m, fglmVector v, fglmVector p, number & denom )
    787787{
    … …  
    793793    int k= 1;
    794794    while ( nIsZero(v.getconstelem(k)) || isPivot[k] ) {
    795         k++;
     795        k++;
    796796    }
    797797    fglmASSERT( k <= dimen, "Error(1) in fglmDdata::pivot-search");
    … …  
    800800    k++;
    801801    while ( k <= dimen ) {
    802         if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
    803             if ( nGreater( v.getconstelem( k ), pivot ) ) {
    804                 pivot= v.getconstelem( k );
    805                 pivotcol= k;
    806             }
    807         }
    808         k++;
     802        if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
     803            if ( nGreater( v.getconstelem( k ), pivot ) ) {
     804                pivot= v.getconstelem( k );
     805                pivotcol= k;
     806            }
     807        }
     808        k++;
    809809    }
    810810    fglmASSERT( ! nIsZero( pivot ), "Error(2) fglmDdata::Pivotelement ist Null" );
    811811    isPivot[ pivotcol ]= TRUE;
    812812    perm[basisSize]= pivotcol;
    813    
     813
    814814    pivot= nCopy( v.getconstelem( pivotcol ) );
    815815#ifndef HAVE_EXPLICIT_CONSTR
    … …  
    829829    int state = 0;
    830830    while ( k >= 1 ) {
    831         newmonom = pCopy( m );
    832         pIncrExp( newmonom, k );
    833         pSetm( newmonom );
    834         done= FALSE;
    835         while ( list.hasItem() && (done == FALSE) ) {
    836             if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
    837                 list++;
    838             else done= TRUE;
    839         }
    840         if ( done == FALSE ) {
    841             nlist.append( fglmDelem( newmonom, v, k ) );
    842             break;
    843         }
    844         if ( state == 0 ) {
    845             list.getItem().newDivisor();
    846             pDelete1( & newmonom );
    847         }
    848         else {
    849             list.insert( fglmDelem( newmonom, v, k ) );
    850         }
    851         k--;
     831        newmonom = pCopy( m );
     832        pIncrExp( newmonom, k );
     833        pSetm( newmonom );
     834        done= FALSE;
     835        while ( list.hasItem() && (done == FALSE) ) {
     836            if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
     837                list++;
     838            else done= TRUE;
     839        }
     840        if ( done == FALSE ) {
     841            nlist.append( fglmDelem( newmonom, v, k ) );
     842            break;
     843        }
     844        if ( state == 0 ) {
     845            list.getItem().newDivisor();
     846            pDelete1( & newmonom );
     847        }
     848        else {
     849            list.insert( fglmDelem( newmonom, v, k ) );
     850        }
     851        k--;
    852852    }
    853853    while ( --k >= 1 ) {
    854         newmonom= pCopy( m );
    855         pIncrExp( newmonom, k );
    856         pSetm( newmonom );
    857         nlist.append( fglmDelem( newmonom, v, k ) );
    858     }
    859 }
    860 
    861 void 
    862 fglmDdata::newGroebnerPoly( fglmVector & p, poly & m ) 
     854        newmonom= pCopy( m );
     855        pIncrExp( newmonom, k );
     856        pSetm( newmonom );
     857        nlist.append( fglmDelem( newmonom, v, k ) );
     858    }
     859}
     860
     861void
     862fglmDdata::newGroebnerPoly( fglmVector & p, poly & m )
    863863// Inserts gp = p[1]*basis(1)+..+p[basisSize]*basis(basisSize)+p[basisSize+1]*m as
    864864//  a new groebner polynomial for the ideal.
    … …  
    873873    m= NULL;
    874874    if ( nGetChar() > 0 ) {
    875         number lead = nCopy( p.getconstelem( basisSize+1 ) );
    876         p /= lead;
    877         nDelete( & lead );
     875        number lead = nCopy( p.getconstelem( basisSize+1 ) );
     876        p /= lead;
     877        nDelete( & lead );
    878878    }
    879879    if ( nGetChar() == 0 ) {
    880         number gcd= p.gcd();
    881         fglmASSERT( ! nIsZero( gcd ), "FATAL: gcd and thus p is zero" );
    882         if ( ! nIsOne( gcd ) )
    883             p /= gcd;
    884         nDelete( & gcd );
     880        number gcd= p.gcd();
     881        fglmASSERT( ! nIsZero( gcd ), "FATAL: gcd and thus p is zero" );
     882        if ( ! nIsOne( gcd ) )
     883            p /= gcd;
     884        nDelete( & gcd );
    885885    }
    886886    pSetCoeff( result, nCopy( p.getconstelem( basisSize+1 ) ) );
    887887    for ( k= basisSize; k > 0; k-- ) {
    888         if ( ! nIsZero( p.getconstelem( k ) ) ) {
    889             temp->next= pCopy( basis[k] );
    890             pIter( temp );
    891             pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
    892         }
     888        if ( ! nIsZero( p.getconstelem( k ) ) ) {
     889            temp->next= pCopy( basis[k] );
     890            pIter( temp );
     891            pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
     892        }
    893893    }
    894894    pSetm( result );
    895895    if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
    896896    if ( groebnerSize == IDELEMS( destId ) ) {
    897         pEnlargeSet( & destId->m, IDELEMS( destId ), groebnerBS );
    898         IDELEMS( destId )+= groebnerBS;
     897        pEnlargeSet( & destId->m, IDELEMS( destId ), groebnerBS );
     898        IDELEMS( destId )+= groebnerBS;
    899899    }
    900900    (destId->m)[groebnerSize]= result;
    … …  
    903903
    904904void
    905 fglmDdata::gaussreduce( fglmVector & v, fglmVector & p, number & pdenom ) 
     905fglmDdata::gaussreduce( fglmVector & v, fglmVector & p, number & pdenom )
    906906{
    907907    int k;
    … …  
    912912    number vdenom = v.clearDenom();
    913913    if ( ! nIsOne( vdenom ) && ! nIsZero( vdenom ) ) {
    914         p.setelem( p.size(), vdenom );
     914        p.setelem( p.size(), vdenom );
    915915    }
    916916    else {
    917         nDelete( &vdenom );
     917        nDelete( &vdenom );
    918918    }
    919919    number gcd = v.gcd();
    920920    if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
    921         v /= gcd;
    922         number temp= nMult( pdenom, gcd );
    923         nDelete( &pdenom );
    924         pdenom= temp;
     921        v /= gcd;
     922        number temp= nMult( pdenom, gcd );
     923        nDelete( &pdenom );
     924        pdenom= temp;
    925925    }
    926926    nDelete( & gcd );
    … …  
    928928    for ( k= 1; k <= basisSize; k++ ) {
    929929
    930         if ( ! v.elemIsZero( perm[k] ) ) {
    931             fac1= gauss[k].fac;
    932             fac2= nCopy( v.getconstelem( perm[k] ) );
    933             v.nihilate( fac1, fac2, gauss[k].v );
    934             fac1= nMult( fac1, gauss[k].pdenom );
    935             temp= nMult( fac2, pdenom );
    936             nDelete( &fac2 );
    937             fac2= temp;
    938             p.nihilate( fac1, fac2, gauss[k].p );
    939             temp= nMult( pdenom, gauss[k].pdenom );
    940             nDelete( &pdenom );
    941             pdenom= temp;
    942 
    943             nDelete( & fac1 );
    944             nDelete( & fac2 );
    945             number gcd = v.gcd();
    946             if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
    947                 v /= gcd;
    948                 number temp= nMult( pdenom, gcd );
    949                 nDelete( &pdenom );
    950                 pdenom= temp;
    951             }
    952             nDelete( & gcd );
    953             gcd= p.gcd();
    954             temp= nGcd( pdenom, gcd );
    955             nDelete( &gcd );
    956             gcd= temp;
    957             if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
    958                 p /= gcd;
    959                 temp= nDiv( pdenom, gcd );
    960                 nDelete( & pdenom );
    961                 pdenom= temp;
    962                 nNormalize( pdenom );
    963             }
    964             nDelete( & gcd );
    965         }
     930        if ( ! v.elemIsZero( perm[k] ) ) {
     931            fac1= gauss[k].fac;
     932            fac2= nCopy( v.getconstelem( perm[k] ) );
     933            v.nihilate( fac1, fac2, gauss[k].v );
     934            fac1= nMult( fac1, gauss[k].pdenom );
     935            temp= nMult( fac2, pdenom );
     936            nDelete( &fac2 );
     937            fac2= temp;
     938              p.nihilate( fac1, fac2, gauss[k].p );
     939            temp= nMult( pdenom, gauss[k].pdenom );
     940            nDelete( &pdenom );
     941            pdenom= temp;
     942
     943            nDelete( & fac1 );
     944            nDelete( & fac2 );
     945            number gcd = v.gcd();
     946            if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
     947                v /= gcd;
     948                number temp= nMult( pdenom, gcd );
     949                nDelete( &pdenom );
     950                pdenom= temp;
     951            }
     952            nDelete( & gcd );
     953            gcd= p.gcd();
     954            temp= nGcd( pdenom, gcd );
     955            nDelete( &gcd );
     956            gcd= temp;
     957            if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
     958                p /= gcd;
     959                temp= nDiv( pdenom, gcd );
     960                nDelete( & pdenom );
     961                pdenom= temp;
     962                nNormalize( pdenom );
     963            }
     964            nDelete( & gcd );
     965        }
    966966    }
    967967}
    … …  
    971971// Calculates the groebnerBasis for the ideal which is defined by l.
    972972// The dimension of l has to be finite.
    973 // The result is in reduced form. 
     973// The result is in reduced form.
    974974{
    975975    fglmDdata data( l.dimen() );
    976    
     976
    977977    // insert pOne() and update workinglist:
    978978    poly one = pOne();
    … …  
    982982    STICKYPROT( "." );
    983983    while ( data.candidatesLeft() == TRUE ) {
    984         fglmDelem candidate = data.nextCandidate();
    985         if ( candidate.isBasisOrEdge() == TRUE ) {
    986             // Now we have the chance to find a new groebner polynomial
    987            
    988             // v is the vector-representation of candidate.monom
    989             // some elements of v are zeroed in data.gaussreduce(). Which
    990             // ones and how this was done is stored in p.
    991             // originalV containes the unchanged v, which is later inserted
    992             // into the working list (via data.updateCandidates().
    993             fglmVector v = l.multiply( candidate.v, candidate.var );
    994             fglmVector originalV = v;
    995             fglmVector p( data.getBasisSize()+1, data.getBasisSize()+1 );
    996             number pdenom = NULL;
    997             data.gaussreduce( v, p, pdenom );
    998             if ( v.isZero() ) {
    999                 // Now v is linear dependend to the already found basis elements.
    1000                 // This means that v (rsp. candidate.monom) is the leading
    1001                 // monomial of the next groebner-basis polynomial.
    1002                 data.newGroebnerPoly( p, candidate.monom );
    1003                 nDelete( & pdenom );
    1004                 STICKYPROT( "+" );
    1005             }
    1006             else {
    1007                 // no linear dependence could be found, so v ( rsp. monom )
    1008                 // is a basis monomial. We store the zeroed version ( i.e. v
    1009                 // and not originalV ) as well as p, the denomiator and all
    1010                 // the other stuff.
    1011                 // erst updateCandidates, dann newBasisELem!!!
    1012                 data.updateCandidates( candidate.monom, originalV );
    1013                 data.newBasisElem( candidate.monom, v, p, pdenom );
    1014                 STICKYPROT( "." );
    1015             }
    1016         }
    1017         else {
    1018             STICKYPROT( "-" );
    1019             candidate.cleanup();
    1020         }
     984        fglmDelem candidate = data.nextCandidate();
     985        if ( candidate.isBasisOrEdge() == TRUE ) {
     986            // Now we have the chance to find a new groebner polynomial
     987
     988            // v is the vector-representation of candidate.monom
     989            // some elements of v are zeroed in data.gaussreduce(). Which
     990            // ones and how this was done is stored in p.
     991            // originalV containes the unchanged v, which is later inserted
     992            // into the working list (via data.updateCandidates().
     993            fglmVector v = l.multiply( candidate.v, candidate.var );
     994            fglmVector originalV = v;
     995            fglmVector p( data.getBasisSize()+1, data.getBasisSize()+1 );
     996            number pdenom = NULL;
     997            data.gaussreduce( v, p, pdenom );
     998            if ( v.isZero() ) {
     999                // Now v is linear dependend to the already found basis elements.
     1000                // This means that v (rsp. candidate.monom) is the leading
     1001                // monomial of the next groebner-basis polynomial.
     1002                data.newGroebnerPoly( p, candidate.monom );
     1003                nDelete( & pdenom );
     1004                STICKYPROT( "+" );
     1005            }
     1006            else {
     1007                // no linear dependence could be found, so v ( rsp. monom )
     1008                // is a basis monomial. We store the zeroed version ( i.e. v
     1009                // and not originalV ) as well as p, the denomiator and all
     1010                // the other stuff.
     1011                // erst updateCandidates, dann newBasisELem!!!
     1012                data.updateCandidates( candidate.monom, originalV );
     1013                data.newBasisElem( candidate.monom, v, p, pdenom );
     1014                STICKYPROT( "." );
     1015            }
     1016        }
     1017        else {
     1018            STICKYPROT( "-" );
     1019            candidate.cleanup();
     1020        }
    10211021    }  //. while data.candidatesLeft()
    10221022    STICKYPROT( "\n" );
    … …  
    10311031    fglmVector p;
    10321032    ideal destIdeal = idInit( pVariables, 1 );
    1033    
     1033
    10341034    int i;
    10351035    BOOLEAN isZero;
    10361036    for ( i= 1; i <= pVariables; i++ ) {
    1037         // main loop
    1038         STICKYPROT2( "(%i)", i );
    1039         gaussReducer gauss( l.dimen() );
    1040         isZero= FALSE;
    1041         v= fglmVector( l.dimen(), 1 );
    1042         while ( isZero == FALSE ) {
    1043             if ( (isZero= gauss.reduce( v )) == TRUE ) {
    1044                 STICKYPROT( "+" );
    1045                 p= gauss.getDependence();
    1046                 number gcd= p.gcd();
    1047                 if ( ! nIsOne( gcd ) ) {
    1048                     p /= gcd;
    1049                 }
    1050                 nDelete( & gcd );
    1051                 int k;
    1052                 poly temp = NULL;
    1053                 poly result;
    1054                 for ( k= p.size(); k > 0; k-- ) {
    1055                     number n = nCopy( p.getconstelem( k ) );
    1056                     if ( ! nIsZero( n ) ) {
    1057                         if ( temp == NULL ) {
    1058                             result= pOne();
    1059                             temp= result;
    1060                         }
    1061                         else {
    1062                             temp->next= pOne();
    1063                             pIter( temp );
    1064                         }
    1065                         pSetCoeff( temp, n );
    1066                         pSetExp( temp, i, k-1 );
    1067                         pSetm( temp );
    1068                     }
    1069                 }
    1070                 if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
    1071                 (destIdeal->m)[i-1]= result;
    1072             }
    1073             else {
    1074                 STICKYPROT( "." );
    1075                 gauss.store();
    1076                 v= l.multiply( v, i );
    1077             }
    1078         }
     1037        // main loop
     1038        STICKYPROT2( "(%i)", i );
     1039        gaussReducer gauss( l.dimen() );
     1040        isZero= FALSE;
     1041        v= fglmVector( l.dimen(), 1 );
     1042        while ( isZero == FALSE ) {
     1043            if ( (isZero= gauss.reduce( v )) == TRUE ) {
     1044                STICKYPROT( "+" );
     1045                p= gauss.getDependence();
     1046                number gcd= p.gcd();
     1047                if ( ! nIsOne( gcd ) ) {
     1048                    p /= gcd;
     1049                }
     1050                nDelete( & gcd );
     1051                int k;
     1052                poly temp = NULL;
     1053                poly result;
     1054                for ( k= p.size(); k > 0; k-- ) {
     1055                    number n = nCopy( p.getconstelem( k ) );
     1056                    if ( ! nIsZero( n ) ) {
     1057                        if ( temp == NULL ) {
     1058                            result= pOne();
     1059                            temp= result;
     1060                        }
     1061                        else {
     1062                            temp->next= pOne();
     1063                            pIter( temp );
     1064                        }
     1065                        pSetCoeff( temp, n );
     1066                        pSetExp( temp, i, k-1 );
     1067                        pSetm( temp );
     1068                    }
     1069                }
     1070                if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
     1071                (destIdeal->m)[i-1]= result;
     1072            }
     1073            else {
     1074                STICKYPROT( "." );
     1075                gauss.store();
     1076                v= l.multiply( v, i );
     1077            }
     1078        }
    10791079    }
    10801080    STICKYPROT( "\n" );
    … …  
    10881088    idhdl initialRingHdl = currRingHdl;
    10891089    BOOLEAN fglmok;
    1090    
     1090
    10911091    if ( currRingHdl != sourceRingHdl )
    1092         rSetHdl( sourceRingHdl, TRUE );
     1092        rSetHdl( sourceRingHdl, TRUE );
    10931093    idealFunctionals L( 100, pVariables );
    10941094    fglmok = CalculateFunctionals( sourceIdeal, L );
    10951095    if ( deleteIdeal == TRUE )
    1096         idDelete( & sourceIdeal );
     1096        idDelete( & sourceIdeal );
    10971097    rSetHdl( destRingHdl, TRUE );
    10981098    if ( fglmok == TRUE ) {
    1099         L.map( IDRING( sourceRingHdl ) );
    1100         destIdeal= GroebnerViaFunctionals( L );
     1099        L.map( IDRING( sourceRingHdl ) );
     1100        destIdeal= GroebnerViaFunctionals( L );
    11011101    }
    11021102    if ( (switchBack == TRUE) && (currRingHdl != initialRingHdl) )
    1103         rSetHdl( initialRingHdl, TRUE );
     1103        rSetHdl( initialRingHdl, TRUE );
    11041104    return fglmok;
    11051105}
    11061106
    11071107BOOLEAN
    1108 FindUnivariateWrapper( ideal source, ideal & destIdeal ) 
     1108FindUnivariateWrapper( ideal source, ideal & destIdeal )
    11091109{
    11101110    BOOLEAN fglmok;
    1111    
     1111
    11121112    idealFunctionals L( 100, pVariables );
    11131113    fglmok = CalculateFunctionals( source, L );
    11141114    if ( fglmok == TRUE ) {
    1115         destIdeal= FindUnivariatePolys( L );
    1116         return TRUE;
    1117     }
    1118     else 
    1119         return FALSE;
     1115        destIdeal= FindUnivariatePolys( L );
     1116        return TRUE;
     1117    }
     1118    else
     1119        return FALSE;
    11201120}
    11211121
Note: See TracChangeset for help on using the changeset viewer.