Changeset 26ac996 in git


Ignore:
Timestamp:
Aug 12, 1999, 2:36:09 PM (25 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')
Children:
e92dd64a013a6d83ff91a3338db2e613f9e7c66c
Parents:
a28950c35e390ee5e90953643f06d81423c93dce
Message:
*hannes/siebert: regularity fix


git-svn-id: file:///usr/local/Singular/svn/trunk@3425 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/ipshell.cc

    ra28950 r26ac996  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipshell.cc,v 1.44 1999-07-13 16:24:44 Singular Exp $ */
     4/* $Id: ipshell.cc,v 1.45 1999-08-12 12:36:09 Singular Exp $ */
    55/*
    66* ABSTRACT:
     
    538538  if (p>j) return j;
    539539  else     return cf_getSmallPrime(i-1);
    540 #else 
     540#else
    541541  for (j=p/2+1,i=3; i<p; i+=2)
    542542  {
     
    768768int iiRegularity(lists L)
    769769{
    770   resolvente r;
    771770  int len,reg,typ0;
    772   intvec * dummy;
    773 
    774   r=liFindRes(L,&len,&typ0);
    775   if (r==NULL) return -2;
    776   dummy=syBetti(r,len,&reg);
     771
     772  resolvente r=liFindRes(L,&len,&typ0);
     773
     774  if (r==NULL)
     775    return -2;
     776  intvec * dummy=syBetti(r,len,&reg);
    777777  Free((ADDRESS)r,len*sizeof(ideal));
    778778  delete dummy;
    779   return reg-1;
     779  return reg;
    780780}
    781781
  • Singular/npolygon.cc

    ra28950 r26ac996  
    3030void    linearForm::copy_new( int k )
    3131{
    32     if( k > 0 )
    33     {
    34         c = new Rational[k];
    35 
    36         #ifndef NBDEBUG
    37         if( c == (Rational*)NULL )
    38         {
    39             #ifdef  NPOLYGON_PRINT
    40             #ifdef  NPOLYGON_IOSTREAM
    41                 cerr << "void linearForm::copy_new( int k )";
    42                 cerr << ": no memory left ..." << endl;
    43             #else
    44                 fprintf( stderr,"void linearForm::copy_new( int k )" );
    45                 fprintf( stderr,": no memory left ...\n" );
    46             #endif
    47             #endif
    48 
    49             exit( 1 );
    50         }
     32  if( k > 0 )
     33  {
     34    c = new Rational[k];
     35
     36    #ifndef NBDEBUG
     37    if( c == (Rational*)NULL )
     38    {
     39      #ifdef  NPOLYGON_PRINT
     40      #ifdef  NPOLYGON_IOSTREAM
     41        cerr <<
     42        "void linearForm::copy_new( int k ): no memory left ...\n" ;
     43      #else
     44        fprintf( stderr,
     45        "void linearForm::copy_new( int k ): no memory left ...\n");
     46      #endif
     47      #endif
     48      HALT();
     49    }
     50    #endif
     51  }
     52  else if( k == 0 )
     53  {
     54    c = (Rational*)NULL;
     55  }
     56  else if( k < 0 )
     57  {
     58    #ifdef  NPOLYGON_PRINT
     59    #ifdef  NPOLYGON_IOSTREAM
     60      cerr <<
     61      "void linearForm::copy_new( int k ): k < 0 ...\n";
     62    #else
     63      fprintf( stderr,
     64      "void linearForm::copy_new( int k ): k < 0 ...\n" );
     65    #endif
     66    #endif
     67
     68    HALT();
     69  }
     70}
     71
     72// ----------------------------------------------------------------------------
     73//  Delete the memory of a linear form
     74// ----------------------------------------------------------------------------
     75
     76void    linearForm::copy_delete( void )
     77{
     78  if( c != (Rational*)NULL && N > 0 )
     79    delete [] c;
     80  copy_zero( );
     81}
     82
     83// ----------------------------------------------------------------------------
     84//  Initialize deep from another linear form
     85// ----------------------------------------------------------------------------
     86
     87void    linearForm::copy_deep( const linearForm &l )
     88{
     89  copy_new( l.N );
     90  for( int i=l.N-1; i>=0; i-- )
     91  {
     92    c[i] = l.c[i];
     93  }
     94  N = l.N;
     95}
     96
     97// ----------------------------------------------------------------------------
     98//  Copy constructor
     99// ----------------------------------------------------------------------------
     100
     101linearForm::linearForm( const linearForm &l )
     102{
     103  copy_deep( l );
     104}
     105
     106// ----------------------------------------------------------------------------
     107//  Destructor
     108// ----------------------------------------------------------------------------
     109
     110linearForm::~linearForm( )
     111{
     112  copy_delete( );
     113}
     114
     115// ----------------------------------------------------------------------------
     116//  Define `=` to be a deep copy
     117// ----------------------------------------------------------------------------
     118
     119linearForm & linearForm::operator = ( const linearForm &l )
     120{
     121  copy_delete( );
     122  copy_deep( l );
     123
     124  return *this;
     125}
     126
     127// ----------------------------------------------------------------------------
     128//  ostream for linear form
     129// ----------------------------------------------------------------------------
     130
     131#ifdef  NPOLYGON_PRINT
     132
     133ostream & operator << ( ostream &s,const linearForm &l )
     134{
     135  for( int i=0; i<l.N; i++ )
     136  {
     137    if( l.c[i] != (Rational)0 )
     138    {
     139      if( i > 0 && l.c[i] >= (Rational)0 )
     140      {
     141        #ifdef NPOLYGON_IOSTREAM
     142          s << "+";
     143        #else
     144          fprintf( stdout,"+" );
    51145        #endif
    52     }
    53     else if( k == 0 )
    54     {
    55         c = (Rational*)NULL;
    56     }
    57     else if( k < 0 )
    58     {
    59         #ifdef  NPOLYGON_PRINT
    60         #ifdef  NPOLYGON_IOSTREAM
    61             cerr << "void linearForm::copy_new( int k )";
    62             cerr << ": k < 0 ..." << endl;
    63         #else
    64             fprintf( stderr,"void linearForm::copy_new( int k )" );
    65             fprintf( stderr,": k < 0 ...\n" );
    66         #endif
    67         #endif
    68 
    69         exit( 1 );
    70     }
    71 }
    72 
    73 // ----------------------------------------------------------------------------
    74 //  Delete the memory of a linear form
    75 // ----------------------------------------------------------------------------
    76 
    77 void    linearForm::copy_delete( void )
    78 {
    79     if( c != (Rational*)NULL && N > 0 ) delete [] c;
    80     copy_zero( );
    81 }
    82 
    83 // ----------------------------------------------------------------------------
    84 //  Initialize deep from another linear form
    85 // ----------------------------------------------------------------------------
    86 
    87 void    linearForm::copy_deep( const linearForm &l )
    88 {
    89     copy_new( l.N );
    90     for( int i=0; i<l.N; i++ )
    91     {
    92         c[i] = l.c[i];
    93     }
    94     N = l.N;
    95 }
    96 
    97 // ----------------------------------------------------------------------------
    98 //  Copy constructor
    99 // ----------------------------------------------------------------------------
    100 
    101 linearForm::linearForm( const linearForm &l )
    102 {
    103     copy_deep( l );
    104 }
    105 
    106 // ----------------------------------------------------------------------------
    107 //  Destructor
    108 // ----------------------------------------------------------------------------
    109 
    110 linearForm::~linearForm( )
    111 {
    112     copy_delete( );
    113 }
    114 
    115 // ----------------------------------------------------------------------------
    116 //  Define `=` to be a deep copy
    117 // ----------------------------------------------------------------------------
    118 
    119 linearForm & linearForm::operator = ( const linearForm &l )
    120 {
    121     copy_delete( );
    122     copy_deep( l );
    123 
    124     return *this;
    125 }
    126 
    127 // ----------------------------------------------------------------------------
    128 //  ostream for linear form
    129 // ----------------------------------------------------------------------------
    130 
    131 #ifdef  NPOLYGON_PRINT
    132 
    133 ostream & operator << ( ostream &s,const linearForm &l )
    134 {
    135     for( int i=0; i<l.N; i++ )
    136     {
    137         if( l.c[i] != (Rational)0 )
    138         {
    139             if( i > 0 && l.c[i] >= (Rational)0 )
    140             {
    141                 #ifdef NPOLYGON_IOSTREAM
    142                     s << "+";
    143                 #else
    144                     fprintf( stdout,"+" );
    145                 #endif
    146             }
    147 
    148             s << l.c[i];
    149 
    150             #ifdef NPOLYGON_IOSTREAM
    151                 s << "*x" << i+1;
    152             #else
    153                 fprintf( stdout,"*x%d",i+1 );
    154             #endif
    155         }
    156     }
    157     return s;
     146      }
     147
     148      s << l.c[i];
     149
     150      #ifdef NPOLYGON_IOSTREAM
     151        s << "*x" << i+1;
     152      #else
     153        fprintf( stdout,"*x%d",i+1 );
     154      #endif
     155    }
     156  }
     157  return s;
    158158}
    159159
     
    166166int     operator == ( const linearForm &l1,const linearForm &l2 )
    167167{
    168     if( l1.N!=l2.N )
    169     {
    170         return  FALSE;
    171     }
    172 
    173     for( int i=0; i<l1.N; i++ )
    174     {
    175         if( l1.c[i]!=l2.c[i] )
    176         {
    177             return  FALSE;
    178         }
    179     }
    180 
    181     return  TRUE;
     168  if( l1.N!=l2.N )
     169    return  FALSE;
     170  for( int i=l1.N-1; i >=0 ; i-- )
     171  {
     172    if( l1.c[i]!=l2.c[i] )
     173      return  FALSE;
     174  }
     175  return  TRUE;
    182176}
    183177
     
    189183Rational linearForm::weight( poly m ) const
    190184{
    191     Rational ret=(Rational)0;
    192 
    193     for( int i=0,j=1; i<N; i++,j++ )
    194     {
    195         ret += c[i]*(Rational)pGetExp( m,j );
    196     }
    197 
    198     return ret;
     185  Rational ret=(Rational)0;
     186
     187  for( int i=0,j=1; i<N; i++,j++ )
     188  {
     189    ret += c[i]*(Rational)pGetExp( m,j );
     190  }
     191
     192  return ret;
    199193}
    200194
     
    205199Rational linearForm::pweight( poly m ) const
    206200{
    207     if( m==(poly)NULL )
    208     {
    209         return  (Rational)0;
    210     }
    211 
    212     Rational    ret = weight( m );
    213     Rational    tmp;
    214 
    215     for( m=m->next; m!=(poly)NULL; m=m->next )
    216     {
    217         tmp = weight( m );
    218 
    219         if( tmp<ret )
    220         {
    221             ret = tmp;
    222         }
    223     }
    224 
    225     return ret;
     201  if( m==(poly)NULL )
     202    return  (Rational)0;
     203
     204  Rational    ret = weight( m );
     205  Rational    tmp;
     206
     207  for( m=pNext(m); m!=(poly)NULL; pIter(m) )
     208  {
     209    tmp = weight( m );
     210    if( tmp<ret )
     211    {
     212      ret = tmp;
     213    }
     214  }
     215
     216  return ret;
    226217}
    227218
     
    232223Rational linearForm::weight_shift( poly m ) const
    233224{
    234     Rational ret=(Rational)0;
    235 
    236     for( int i=0,j=1; i<N; i++,j++ )
    237     {
    238         ret += c[i]*(Rational)( pGetExp( m,j ) + 1 );
    239     }
    240 
    241     return ret;
     225  Rational ret=(Rational)0;
     226
     227  for( int i=0,j=1; i<N; i++,j++ )
     228  {
     229    ret += c[i]*(Rational)( pGetExp( m,j ) + 1 );
     230  }
     231
     232  return ret;
    242233}
    243234
     
    248239Rational linearForm::weight1( poly m ) const
    249240{
    250     Rational ret=(Rational)0;
    251 
    252     for( int i=0,j=2; i<N; i++,j++ )
    253     {
    254         ret += c[i]*(Rational)pGetExp( m,j );
    255     }
    256 
    257     return ret;
     241  Rational ret=(Rational)0;
     242
     243  for( int i=0,j=2; i<N; i++,j++ )
     244  {
     245    ret += c[i]*(Rational)pGetExp( m,j );
     246  }
     247
     248  return ret;
    258249}
    259250
     
    265256Rational linearForm::weight_shift1( poly m ) const
    266257{
    267     Rational ret=(Rational)0;
    268 
    269     for( int i=0,j=2; i<N; i++,j++ )
    270     {
    271         ret += c[i]*(Rational)( pGetExp( m,j ) + 1 );
    272     }
    273 
    274     return ret;
     258  Rational ret=(Rational)0;
     259
     260  for( int i=0,j=2; i<N; i++,j++ )
     261  {
     262    ret += c[i]*(Rational)( pGetExp( m,j ) + 1 );
     263  }
     264
     265  return ret;
    275266}
    276267
     
    282273int linearForm::positive( void )
    283274{
    284     for( int i=0; i<N; i++ )
    285     {
    286         if( c[i] <= (Rational)0 )
    287         {
    288             return FALSE;
    289         }
    290     }
    291     return  TRUE;
     275  for( int i=0; i<N; i++ )
     276  {
     277    if( c[i] <= (Rational)0 )
     278    {
     279      return FALSE;
     280    }
     281  }
     282  return  TRUE;
    292283}
    293284
     
    299290void    newtonPolygon::copy_new( int k )
    300291{
    301     if( k > 0 )
    302     {
    303         l = new linearForm[k];
    304 
    305         #ifndef NDEBUG
    306         if( l == (linearForm*)NULL )
    307         {
    308             #ifdef  NPOLYGON_PRINT
    309             #ifdef  NPOLYGON_IOSTREAM
    310                 cerr << "void newtonPolygon::copy_new( int k )";
    311                 cerr << ": no memory left ..." << endl;
    312             #else
    313                 fprintf( stderr,"void newtonPolygon::copy_new( int k )" );
    314                 fprintf( stderr,": no memory left ...\n" );
    315             #endif
    316             #endif
    317 
    318             exit( 1 );
    319         }
     292  if( k > 0 )
     293  {
     294    l = new linearForm[k];
     295
     296    #ifndef NDEBUG
     297      if( l == (linearForm*)NULL )
     298      {
     299        #ifdef  NPOLYGON_PRINT
     300          #ifdef  NPOLYGON_IOSTREAM
     301            cerr <<
     302            "void newtonPolygon::copy_new( int k ): no memory left ...\n";
     303          #else
     304            fprintf( stderr,
     305            "void newtonPolygon::copy_new( int k ): no memory left ...\n" );
     306          #endif
    320307        #endif
    321     }
    322     else if( k == 0 )
    323     {
    324         l = (linearForm*)NULL;
    325     }
    326     else if( k < 0 )
    327     {
    328         #ifdef  NPOLYGON_PRINT
    329         #ifdef  NPOLYGON_IOSTREAM
    330             cerr << "void newtonPolygon::copy_new( int k )";
    331             cerr << ": k < 0 ..." << endl;
    332         #else
    333             fprintf( stderr,"void newtonPolygon::copy_new( int k )" );
    334             fprintf( stderr,": k < 0 ...\n" );
    335         #endif
    336         #endif
    337 
    338         exit( 1 );
    339     }
     308
     309        HALT();
     310      }
     311    #endif
     312  }
     313  else if( k == 0 )
     314  {
     315    l = (linearForm*)NULL;
     316  }
     317  else if( k < 0 )
     318  {
     319    #ifdef  NPOLYGON_PRINT
     320      #ifdef  NPOLYGON_IOSTREAM
     321        cerr << "void newtonPolygon::copy_new( int k ): k < 0 ...\n";
     322      #else
     323        fprintf( stderr,
     324        "void newtonPolygon::copy_new( int k ): k < 0 ...\n" );
     325      #endif
     326    #endif
     327
     328    HALT();
     329  }
    340330}
    341331
     
    346336void    newtonPolygon::copy_delete( void )
    347337{
    348     if( l != (linearForm*)NULL && N > 0 ) delete [] l;
    349     copy_zero( );
     338  if( l != (linearForm*)NULL && N > 0 )
     339    delete [] l;
     340  copy_zero( );
    350341}
    351342
     
    356347void    newtonPolygon::copy_deep( const newtonPolygon &np )
    357348{
    358     copy_new( np.N );
    359     for( int i=0; i<np.N; i++ )
    360     {
    361         l[i] = np.l[i];
    362     }
    363     N = np.N;
     349  copy_new( np.N );
     350  for( int i=0; i<np.N; i++ )
     351  {
     352    l[i] = np.l[i];
     353  }
     354  N = np.N;
    364355}
    365356
     
    370361newtonPolygon::newtonPolygon( const newtonPolygon &np )
    371362{
    372     copy_deep( np );
     363  copy_deep( np );
    373364}
    374365
     
    379370newtonPolygon::~newtonPolygon( )
    380371{
    381     copy_delete( );
     372  copy_delete( );
    382373}
    383374
     
    388379newtonPolygon & newtonPolygon::operator = ( const newtonPolygon &np )
    389380{
    390     copy_delete( );
    391     copy_deep( np );
    392 
    393     return *this;
     381  copy_delete( );
     382  copy_deep( np );
     383
     384  return *this;
    394385}
    395386
     
    400391newtonPolygon::newtonPolygon( poly f )
    401392{
    402     copy_zero( );
    403 
    404     int *r=new int[pVariables];
    405     poly *m=new poly[pVariables];
    406 
    407 
    408     KMatrix<Rational> mat( pVariables,pVariables+1 );
    409 
    410     int i,j,stop=FALSE;
    411     linearForm sol;
    412 
    413     // ---------------
    414     //  init counters
    415     // ---------------
     393  copy_zero( );
     394
     395  int *r=new int[pVariables];
     396  poly *m=new poly[pVariables];
     397
     398
     399  KMatrix<Rational> mat( pVariables,pVariables+1 );
     400
     401  int i,j,stop=FALSE;
     402  linearForm sol;
     403
     404  // ---------------
     405  //  init counters
     406  // ---------------
     407
     408  for( i=0; i<pVariables; i++ )
     409  {
     410    r[i] = i;
     411  }
     412
     413  m[0] = f;
     414
     415  for( i=1; i<pVariables; i++ )
     416  {
     417    m[i] = pNext(m[i-1]);
     418  }
     419
     420  // -----------------------------
     421  //  find faces (= linear forms)
     422  // -----------------------------
     423
     424  do
     425  {
     426    // ---------------------------------------------------
     427    //  test if monomials p.m[r[0]]m,...,p.m[r[p.vars-1]]
     428    //  are linearely independent
     429    // ---------------------------------------------------
    416430
    417431    for( i=0; i<pVariables; i++ )
    418432    {
    419         r[i] = i;
    420     }
    421 
    422     m[0] = f;
    423 
    424     for( i=1; i<pVariables; i++ )
    425     {
    426         m[i] = m[i-1]->next;
    427     }
    428 
    429     // -----------------------------
    430     //  find faces (= linear forms)
    431     // -----------------------------
    432 
    433         do
    434         {
    435             // ---------------------------------------------------
    436               //  test if monomials p.m[r[0]]m,...,p.m[r[p.vars-1]]
    437             //  are linearely independent
    438             // ---------------------------------------------------
    439 
    440             for( i=0; i<pVariables; i++ )
    441             {
    442                 for( j=0; j<pVariables; j++ )
    443                 {
    444                   //    mat.set( i,j,pGetExp( m[r[i]],j+1 ) );
    445                     mat.set( i,j,pGetExp( m[i],j+1 ) );
    446                 }
    447                 mat.set( i,j,1 );
    448             }
    449 
    450             if( mat.solve( &(sol.c),&(sol.N) ) == pVariables )
    451             {
    452                 // ---------------------------------
    453                 //  check if linearForm is positive
    454                 //  check if linearForm is extremal
    455                 // ---------------------------------
    456 
    457                 if( sol.positive( ) && sol.pweight( f ) >= (Rational)1 )
    458                 {
    459                     // ----------------------------------
    460                     //  this is a face or the polyhedron
    461                     // ----------------------------------
    462 
    463                     add_linearForm( sol );
    464                     sol.c = (Rational*)NULL;
    465                     sol.N = 0;
    466                 }
    467             }
    468 
    469             // --------------------
    470             //  increment counters
    471             // --------------------
    472 
    473             for( i=1; r[i-1] + 1 == r[i] && i < pVariables; i++ );
    474 
    475             for( j=0; j<i-1; j++ )
    476             {
    477                 r[j]=j;
    478             }
    479 
    480             if( i>1 )
    481             {
    482                 m[0]=f;
    483                 for( j=1; j<i-1; j++ )
    484                 {
    485                     m[j]=m[j-1]->next;
    486                 }
    487             }
    488             r[i-1]++;
    489             m[i-1]=m[i-1]->next;
    490 
    491             if( m[pVariables-1] == (poly)NULL )
    492             {
    493                 stop = TRUE;
    494             }
    495         }
    496         while( stop == FALSE );
     433      for( j=0; j<pVariables; j++ )
     434      {
     435        //    mat.set( i,j,pGetExp( m[r[i]],j+1 ) );
     436        mat.set( i,j,pGetExp( m[i],j+1 ) );
     437      }
     438      mat.set( i,j,1 );
     439    }
     440
     441    if( mat.solve( &(sol.c),&(sol.N) ) == pVariables )
     442    {
     443      // ---------------------------------
     444      //  check if linearForm is positive
     445      //  check if linearForm is extremal
     446      // ---------------------------------
     447
     448      if( sol.positive( ) && sol.pweight( f ) >= (Rational)1 )
     449      {
     450        // ----------------------------------
     451        //  this is a face or the polyhedron
     452        // ----------------------------------
     453
     454        add_linearForm( sol );
     455        sol.c = (Rational*)NULL;
     456        sol.N = 0;
     457      }
     458    }
     459
     460    // --------------------
     461    //  increment counters
     462    // --------------------
     463
     464    for( i=1; r[i-1] + 1 == r[i] && i < pVariables; i++ );
     465
     466    for( j=0; j<i-1; j++ )
     467    {
     468      r[j]=j;
     469    }
     470
     471    if( i>1 )
     472    {
     473      m[0]=f;
     474      for( j=1; j<i-1; j++ )
     475      {
     476        m[j]=pNext(m[j-1]);
     477      }
     478    }
     479    r[i-1]++;
     480    m[i-1]=pNext(m[i-1]);
     481
     482    if( m[pVariables-1] == (poly)NULL )
     483    {
     484      stop = TRUE;
     485    }
     486  } while( stop == FALSE );
    497487}
    498488
     
    501491ostream & operator << ( ostream &s,const newtonPolygon &a )
    502492{
     493  #ifdef NPOLYGON_IOSTREAM
     494    s << "Newton polygon:" << endl;
     495  #else
     496    fprintf( stdout,"Newton polygon:\n" );
     497  #endif
     498
     499  for( int i=0; i<a.N; i++ )
     500  {
     501    s << a.l[i];
     502
    503503    #ifdef NPOLYGON_IOSTREAM
    504         s << "Newton polygon:" << endl;
     504      s << endl;
    505505    #else
    506         fprintf( stdout,"Newton polygon:\n" );
     506      fprintf( stdout,"\n" );
    507507    #endif
    508 
    509     for( int i=0; i<a.N; i++ )
    510     {
    511         s << a.l[i];
    512 
    513         #ifdef NPOLYGON_IOSTREAM
    514            s << endl;
    515         #else
    516             fprintf( stdout,"\n" );
    517         #endif
    518     }
    519 
    520     return s;
     508  }
     509
     510  return s;
    521511}
    522512
     
    529519void    newtonPolygon::add_linearForm( const linearForm &l0 )
    530520{
    531     int           i;
    532     newtonPolygon np;
    533 
    534     // -------------------------------------
    535     //  test if linear form is already here
    536     // -------------------------------------
    537 
    538     for( i=0; i<N; i++ )
    539     {
    540         if( l0==l[i] )
    541         {
    542             return;
    543         }
    544     }
    545 
    546     np.copy_new( N+1 );
    547     np.N = N+1;
    548 
    549     for( i=0; i<N; i++ )
    550     {
    551         np.l[i].copy_shallow( l[i] );
    552         l[i].copy_zero( );
    553     }
    554 
    555     np.l[N] = l0;
    556 
    557     copy_delete( );
    558     copy_shallow( np );
    559     np.copy_zero( );
    560 
    561     return;
     521  int           i;
     522  newtonPolygon np;
     523
     524  // -------------------------------------
     525  //  test if linear form is already here
     526  // -------------------------------------
     527
     528  for( i=0; i<N; i++ )
     529  {
     530    if( l0==l[i] )
     531    {
     532      return;
     533    }
     534  }
     535
     536  np.copy_new( N+1 );
     537  np.N = N+1;
     538
     539  for( i=0; i<N; i++ )
     540  {
     541    np.l[i].copy_shallow( l[i] );
     542    l[i].copy_zero( );
     543  }
     544
     545  np.l[N] = l0;
     546
     547  copy_delete( );
     548  copy_shallow( np );
     549  np.copy_zero( );
     550
     551  return;
    562552}
    563553
     
    568558Rational  newtonPolygon::weight( poly m ) const
    569559{
    570     Rational ret = l[0].weight( m );
    571     Rational tmp;
    572 
    573     for( int i=1; i<N; i++ )
    574     {
    575         tmp = l[i].weight( m );
    576 
    577         if( tmp < ret )
    578         {
    579             ret = tmp;
    580         }
    581     }
    582     return ret;
     560  Rational ret = l[0].weight( m );
     561  Rational tmp;
     562
     563  for( int i=1; i<N; i++ )
     564  {
     565    tmp = l[i].weight( m );
     566
     567    if( tmp < ret )
     568    {
     569      ret = tmp;
     570    }
     571  }
     572  return ret;
    583573}
    584574
     
    589579Rational  newtonPolygon::weight_shift( poly m ) const
    590580{
    591     Rational ret = l[0].weight_shift( m );
    592     Rational tmp;
    593 
    594     for( int i=1; i<N; i++ )
    595     {
    596         tmp = l[i].weight_shift( m );
    597 
    598         if( tmp < ret )
    599         {
    600             ret = tmp;
    601         }
    602     }
    603     return ret;
     581  Rational ret = l[0].weight_shift( m );
     582  Rational tmp;
     583
     584  for( int i=1; i<N; i++ )
     585  {
     586    tmp = l[i].weight_shift( m );
     587
     588    if( tmp < ret )
     589    {
     590      ret = tmp;
     591    }
     592  }
     593  return ret;
    604594}
    605595
     
    610600Rational  newtonPolygon::weight1( poly m ) const
    611601{
    612     Rational ret = l[0].weight1( m );
    613     Rational tmp;
    614 
    615     for( int i=1; i<N; i++ )
    616     {
    617         tmp = l[i].weight1( m );
    618 
    619         if( tmp < ret )
    620         {
    621             ret = tmp;
    622         }
    623     }
    624     return ret;
     602  Rational ret = l[0].weight1( m );
     603  Rational tmp;
     604
     605  for( int i=1; i<N; i++ )
     606  {
     607    tmp = l[i].weight1( m );
     608
     609    if( tmp < ret )
     610    {
     611      ret = tmp;
     612    }
     613  }
     614  return ret;
    625615}
    626616
     
    632622Rational  newtonPolygon::weight_shift1( poly m ) const
    633623{
    634     Rational ret = l[0].weight_shift1( m );
    635     Rational tmp;
    636 
    637     for( int i=1; i<N; i++ )
    638     {
    639         tmp = l[i].weight_shift1( m );
    640 
    641         if( tmp < ret )
    642         {
    643             ret = tmp;
    644         }
    645     }
    646     return ret;
     624  Rational ret = l[0].weight_shift1( m );
     625  Rational tmp;
     626
     627  for( int i=1; i<N; i++ )
     628  {
     629    tmp = l[i].weight_shift1( m );
     630
     631    if( tmp < ret )
     632    {
     633      ret = tmp;
     634    }
     635  }
     636  return ret;
    647637}
    648638
     
    655645int     newtonPolygon::is_sqh( void ) const
    656646{
    657     return ( N==1 ? TRUE : FALSE );
     647  return ( N==1 ? TRUE : FALSE );
    658648}
    659649
     
    665655Rational*   newtonPolygon::sqh_weights( void ) const
    666656{
    667     return ( N==1 ? l[0].c : (Rational*)NULL );
     657  return ( N==1 ? l[0].c : (Rational*)NULL );
    668658}
    669659
    670660int    newtonPolygon::sqh_N( void ) const
    671661{
    672     return ( N==1 ? l[0].N : 0 );
     662  return ( N==1 ? l[0].N : 0 );
    673663}
    674664*/
Note: See TracChangeset for help on using the changeset viewer.