Changeset b938f4 in git for kernel/npolygon.cc

Timestamp:

Jul 19, 2011, 12:55:56 PM (13 years ago)

Author:

mlee <martinlee84@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

22a09d7b2686f280e5afec3b39bd5e02739c9a40

Parents:

ed47edfe6cd330b5befd43ea05889c3359a9d64a

git-author:

mlee <martinlee84@web.de>2011-07-19 12:55:56+02:00

git-committer:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:39:57+01:00

Message:

added const ring r argument to all ring dependend functions
commented out MAX_INT_VAL in mod2.h

File:

• kernel/npolygon.cc (modified) (21 diffs)

kernel/npolygon.cc

@@ -19 +19 @@
 #endif
 
-#include <polys/polys.h>
+//#include <polys/polys.h>
+#include <polys/monomials/p_polys.h>
+#include <polys/monomials/ring.h>
+
 #include <kernel/GMPrat.h>
 #include <kernel/kmatrix.h>
 #include <kernel/npolygon.h>
+#include <kernel/structs.h>
 
 // ----------------------------------------------------------------------------
@@ -181 +185 @@
 // ----------------------------------------------------------------------------
 
-Rational linearForm::weight( poly m ) const
+Rational linearForm::weight( poly m, const ring r ) const
 {
   Rational ret=(Rational)0;
@@ -187 +191 @@
   for( int i=0,j=1; i<N; i++,j++ )
   {
-    ret += c[i]*(Rational)pGetExp( m,j );
+    ret += c[i]*(Rational)p_GetExp( m,j,r );
   }
 
@@ -197 +201 @@
 // ----------------------------------------------------------------------------
 
-Rational linearForm::pweight( poly m ) const
+Rational linearForm::pweight( poly m, const ring r ) const
 {
   if( m==(poly)NULL )
     return  (Rational)0;
 
-  Rational    ret = weight( m );
+  Rational    ret = weight( m, r );
   Rational    tmp;
 
   for( m=pNext(m); m!=(poly)NULL; pIter(m) )
   {
-    tmp = weight( m );
+    tmp = weight( m, r );
     if( tmp<ret )
     {
@@ -221 +225 @@
 // ----------------------------------------------------------------------------
 
-Rational linearForm::weight_shift( poly m ) const
+Rational linearForm::weight_shift( poly m, const ring r ) const
 {
   Rational ret=(Rational)0;
@@ -227 +231 @@
   for( int i=0,j=1; i<N; i++,j++ )
   {
-    ret += c[i]*(Rational)( pGetExp( m,j ) + 1 );
+    ret += c[i]*(Rational)( p_GetExp( m,j,r ) + 1 );
   }
 
@@ -237 +241 @@
 // ----------------------------------------------------------------------------
 
-Rational linearForm::weight1( poly m ) const
+Rational linearForm::weight1( poly m, const ring r ) const
 {
   Rational ret=(Rational)0;
@@ -243 +247 @@
   for( int i=0,j=2; i<N; i++,j++ )
   {
-    ret += c[i]*(Rational)pGetExp( m,j );
+    ret += c[i]*(Rational)p_GetExp( m,j,r );
   }
 
@@ -254 +258 @@
 // ----------------------------------------------------------------------------
 
-Rational linearForm::weight_shift1( poly m ) const
+Rational linearForm::weight_shift1( poly m, const ring r ) const
 {
   Rational ret=(Rational)0;
@@ -260 +264 @@
   for( int i=0,j=2; i<N; i++,j++ )
   {
-    ret += c[i]*(Rational)( pGetExp( m,j ) + 1 );
+    ret += c[i]*(Rational)( p_GetExp( m,j,r ) + 1 );
   }
 
@@ -389 +393 @@
 // ----------------------------------------------------------------------------
 
-newtonPolygon::newtonPolygon( poly f )
+newtonPolygon::newtonPolygon( poly f, const ring s )
 {
   copy_zero( );
 
-  int *r=new int[pVariables];
-  poly *m=new poly[pVariables];
-
-
-  KMatrix<Rational> mat( pVariables,pVariables+1 );
+  int *r=new int[s->N];
+  poly *m=new poly[s->N];
+
+
+  KMatrix<Rational> mat(s->N,s->N+1 );
 
   int i,j,stop=FALSE;
@@ -406 +410 @@
   // ---------------
 
-  for( i=0; i<pVariables; i++ )
+  for( i=0; i<s->N; i++ )
   {
     r[i] = i;
@@ -413 +417 @@
   m[0] = f;
 
-  for( i=1; i<pVariables; i++ )
+  for( i=1; i<s->N; i++ )
   {
     m[i] = pNext(m[i-1]);
@@ -429 +433 @@
     // ---------------------------------------------------
 
-    for( i=0; i<pVariables; i++ )
-    {
-      for( j=0; j<pVariables; j++ )
+    for( i=0; i<s->N; i++ )
+    {
+      for( j=0; j<s->N; j++ )
       {
         //    mat.set( i,j,pGetExp( m[r[i]],j+1 ) );
-        mat.set( i,j,pGetExp( m[i],j+1 ) );
+        mat.set( i,j,p_GetExp( m[i],j+1,s ) );
       }
       mat.set( i,j,1 );
     }
 
-    if( mat.solve( &(sol.c),&(sol.N) ) == pVariables )
+    if( mat.solve( &(sol.c),&(sol.N) ) == s->N )
     {
       // ---------------------------------
@@ -446 +450 @@
       // ---------------------------------
 
-      if( sol.positive( ) && sol.pweight( f ) >= (Rational)1 )
+      if( sol.positive( ) && sol.pweight( f,s ) >= (Rational)1 )
       {
         // ----------------------------------
@@ -462 +466 @@
     // --------------------
 
-    for( i=1; r[i-1] + 1 == r[i] && i < pVariables; i++ );
+    for( i=1; r[i-1] + 1 == r[i] && i < s->N; i++ );
 
     for( j=0; j<i-1; j++ )
@@ -480 +484 @@
     m[i-1]=pNext(m[i-1]);
 
-    if( m[pVariables-1] == (poly)NULL )
+    if( m[s->N-1] == (poly)NULL )
     {
       stop = TRUE;
@@ -556 +560 @@
 // ----------------------------------------------------------------------------
 
-Rational  newtonPolygon::weight( poly m ) const
-{
-  Rational ret = l[0].weight( m );
+Rational  newtonPolygon::weight( poly m, const ring r ) const
+{
+  Rational ret = l[0].weight( m,r );
   Rational tmp;
 
   for( int i=1; i<N; i++ )
   {
-    tmp = l[i].weight( m );
+    tmp = l[i].weight( m,r );
 
     if( tmp < ret )
@@ -577 +581 @@
 // ----------------------------------------------------------------------------
 
-Rational  newtonPolygon::weight_shift( poly m ) const
-{
-  Rational ret = l[0].weight_shift( m );
+Rational  newtonPolygon::weight_shift( poly m, const ring r ) const
+{
+  Rational ret = l[0].weight_shift( m, r );
   Rational tmp;
 
   for( int i=1; i<N; i++ )
   {
-    tmp = l[i].weight_shift( m );
+    tmp = l[i].weight_shift( m, r );
 
     if( tmp < ret )
@@ -598 +602 @@
 // ----------------------------------------------------------------------------
 
-Rational  newtonPolygon::weight1( poly m ) const
-{
-  Rational ret = l[0].weight1( m );
+Rational  newtonPolygon::weight1( poly m, const ring r ) const
+{
+  Rational ret = l[0].weight1( m, r );
   Rational tmp;
 
   for( int i=1; i<N; i++ )
   {
-    tmp = l[i].weight1( m );
+    tmp = l[i].weight1( m, r );
 
     if( tmp < ret )
@@ -620 +624 @@
 // ----------------------------------------------------------------------------
 
-Rational  newtonPolygon::weight_shift1( poly m ) const
-{
-  Rational ret = l[0].weight_shift1( m );
+Rational  newtonPolygon::weight_shift1( poly m, const ring r ) const
+{
+  Rational ret = l[0].weight_shift1( m, r );
   Rational tmp;
 
   for( int i=1; i<N; i++ )
   {
-    tmp = l[i].weight_shift1( m );
+    tmp = l[i].weight_shift1( m, r );
 
     if( tmp < ret )