Changeset 9f609e6 in git


Ignore:
Timestamp:
Apr 5, 2000, 12:03:09 PM (24 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
78f2216c4ff0ad23f68b4cdfcdbeabbd8107d8f3
Parents:
69526d5b2781892b526a1ff184aafbda1f1c5b9b
Message:
*hannes: cosmetics


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

Legend:

Unmodified
Added
Removed

  • factory/sm_sparsemod.cc

    r69526d5 r9f609e6  
    11/* emacs edit mode for this file is -*- C++ -*- */
    2 /* $Id: sm_sparsemod.cc,v 1.7 1998-03-12 14:31:13 schmidt Exp $ */
     2/* $Id: sm_sparsemod.cc,v 1.8 2000-04-05 10:03:09 Singular Exp $ */
    33
    44//{{{ docu
    … …  
    5858      return gcd( v, u );
    5959
    60 
    61 
    62 
    6360  //   u und v Polynome in levU - Variablen x1, ..., xlevU
    6461  //   mit den gleichen Variablen, welches in sparsemod gesichert wurde
    6562
    6663  int levU = level( u );
    67 
    68 
    6964  CFArray G( 1, levU );
    7065  Variable x( 1 );
    … …  
    7873
    7974  if( alpha(lcggt) != 0 && degree(G[1]) != 0 )
    80     {
    81       //G[1] =( alpha( lcggt ))*( ( 1/lc( G[1] ) ) * G[1] );
    82       G[1] =( alpha( lcggt ))*( ( 1/Leitkoeffizient( G[1] ) ) * G[1] );
    83 
    84     }
    85 
    86 
     75  {
     76    //G[1] =( alpha( lcggt ))*( ( 1/lc( G[1] ) ) * G[1] );
     77    G[1] =( alpha( lcggt ))*( ( 1/Leitkoeffizient( G[1] ) ) * G[1] );
     78  }
    8779
    8880  if ( degree( G[1]) < 0 )
    89     {
    90 
    91      return 1 ;
    92     }
     81  {
     82   return 1 ;
     83  }
    9384
    9485
    9586  if ( degree( G[1] ) == 0 )
    96     {
    97       // zwei Auswertungen um sicherzugehen, dass gcd Eins ist!
    98 
    99       return 1;
    100     }
    101 
     87  {
     88    // zwei Auswertungen um sicherzugehen, dass gcd Eins ist!
     89    return 1;
     90  }
    10291
    10392  CFIterator J = G[ 1 ];
    … …  
    10998
    11099  while ( J.hasTerms() )
    111     {
    112       g[ i ] = J.coeff() ;
    113       emma[ i ] = J.exp();
    114       J++;
    115       i++;
    116     }
    117 
     100  {
     101    g[ i ] = J.coeff() ;
     102    emma[ i ] = J.exp();
     103    J++;
     104    i++;
     105  }
    118106
    119107  m = i-1;           /// Anzahl der Terme bzgl x1
    … …  
    129117
    130118  for( s = 2 ;s <= levU ; s++ )
    131     {
    132       U[ s ] = alpha( u, s+1, levU );  // s Variablen stehen lassen, fuer
    133       V[ s ] = alpha( v, s+1, levU );  // den Rest alpha einsetzen
    134 
    135       d = tmin( degree( U[ s ], s ), degree( V[ s ], s ));
    136 
    137       DEBOUTLN( cerr, " U["<< s << "] = " << U[s] );
    138       DEBOUTLN( cerr, " V["<< s << "] = " << V[s] );
    139       DEBOUTLN( cerr, " d = " << d );
    140 
    141 
     119  {
     120    U[ s ] = alpha( u, s+1, levU );  // s Variablen stehen lassen, fuer
     121    V[ s ] = alpha( v, s+1, levU );  // den Rest alpha einsetzen
     122    d = tmin( degree( U[ s ], s ), degree( V[ s ], s ));
     123
     124    DEBOUTLN( cerr, " U["<< s << "] = " << U[s] );
     125    DEBOUTLN( cerr, " V["<< s << "] = " << V[s] );
     126    DEBOUTLN( cerr, " d = " << d );
     127
     128    for ( i = 1; i <= m ; i++ )
     129    {
     130      // Anzahl der Monome berechnen pro gi liefert das Skeletonpolynom //
     131      n[ i ] = countmonome( g[ i ] );
     132      //cout << "n["<<i<<"] = "<< n[i] << endl;
     133    }
     134
     135    for ( i = 1; i <= m    ; i++ )
     136    {
     137      if ( i ==1 )
     138        N = n[i];
     139      else
     140      {
     141        if ( n[i]> N )
     142          N = n[i];
     143      }
     144    }
     145
     146    //      int tau[d+1][m+1][N+1];               /// keine Integers !!!
     147    typedef CanonicalForm** CF_ptr_ptr;
     148    typedef CanonicalForm* CF_ptr;
     149
     150    CanonicalForm ***tau = new CF_ptr_ptr[m+1];
     151    for ( i = 1; i <= m; i++ )
     152    {
     153      tau[i] = new CF_ptr[d+1];
     154      for ( j = 1; j <= d; j++ )
     155        tau[i][j] = new CanonicalForm[N+1];
     156    }
     157
     158    CFArray beta( 1, d );
     159
     160    for ( i = 1; i <= d ; i++ )
     161    {
     162      beta[ i ] =  gen.generate();   // verschiedene Elemente aus Zp
     163      //  cout << "  beta["<<i << "] = " << beta[i];
     164    }
     165
     166    Array<REvaluation> xi( 1, N );
     167    REvaluation a( 2, s-1, gen  );
     168
     169    for ( i = 1 ; i <= N ; i++ )
     170    {
     171      a.nextpoint();
     172      xi[ i ] = a;//REvaluation( 2, s-1, gen );
     173      // cout << "  xi["<<i<<"] = "<< xi[i];
     174    }
     175
     176    //CFArray T(1, d*N );
     177
     178    if ( d == 0 )
     179    {
     180      ASSERT( 0, "alpha bad point! try some other gcd algorithm" );
     181      return gcd(u, v);
     182    }
     183
     184    CFMatrix T( d, N ) ;  // diese Moeglichkeit laeuft!!!
     185                    //help = Koeff( T( j, k ), emma[ i ] );
     186                    //tau[i][j][k] = help; //.intval();
     187
     188    for ( j = 1 ; j <= d ; j++ ) // jedesmal andere REvaluation??
     189    {
     190      for ( k = 1 ; k <= N ; k++ )
     191      {
     192        CanonicalForm zwischenu, zwischenv, help, nfa ;
     193
     194        zwischenu = U[ s ]( beta[ j ], s );
     195        zwischenv = V[ s ]( beta[ j ], s );
     196
     197        T( j, k) = gcd ( xi[k]( zwischenu, 2, s-1 ), xi[k]( zwischenv, 2, s-1 ));
     198
     199        nfa = lcggt( beta[j], s );
     200        nfa =  alpha( nfa, s+1, levU );
     201
     202        //T(j, k ) = (xi[k]( nfa, 2, s-1 ))*((1/lc(T( j, k ))) * T( j, k ));
     203        T(j, k ) = (xi[k]( nfa, 2, s-1 ))*((1/Leitkoeffizient(T( j, k ))) * T( j, k ));
     204
     205        //cout <<"T("<<j<<", "<< k <<") = " << T(j, k) << endl;
     206
     207        for ( i = 1 ; i <= m ; i++ )
     208        {
     209          // diese Moeglichkeit laeuft!!!
     210          //help = Koeff( T( j, k ), emma[ i ] );
     211          //tau[i][j][k] = help; //.intval();
     212          if ( T( j, k).inBaseDomain() )
     213          {
     214            if ( emma[i] == 0 )
     215              tau[i][j][k] = T( j, k );
     216            else
     217              tau[i][j][k] =  0 ;
     218          }
     219          else
     220          {
     221            tau[i][j][k] = T(j, k)[emma[i]];
     222          }
     223        }
     224      }
     225
     226      CFMatrix h( m, d );
    142227
    143228      for ( i = 1; i <= m ; i++ )
    144         {
    145           // Anzahl der Monome berechnen pro gi liefert das Skeletonpolynom //
    146 
    147           n[ i ] = countmonome( g[ i ] );
    148           //cout << "n["<<i<<"] = "<< n[i] << endl;
    149         }
    150 
    151 
    152 
    153       for ( i = 1; i <= m    ; i++ )
    154         {
    155           if ( i ==1 )
    156             N = n[i];
    157           else
    158             {
    159               if ( n[i]> N )
    160                 N = n[i];
    161             }
    162         }
    163 
    164 
    165       //      int tau[d+1][m+1][N+1];               /// keine Integers !!!
    166       typedef CanonicalForm** CF_ptr_ptr;
    167       typedef CanonicalForm* CF_ptr;
    168 
    169       CanonicalForm ***tau = new CF_ptr_ptr[m+1];
    170       for ( i = 1; i <= m; i++ ) {
    171         tau[i] = new CF_ptr[d+1];
    172         for ( j = 1; j <= d; j++ )
    173           tau[i][j] = new CanonicalForm[N+1];
    174       }
    175 
    176       CFArray beta( 1, d );
    177 
    178       for ( i = 1; i <= d ; i++ )
    179         {
    180           beta[ i ] =  gen.generate();   // verschiedene Elemente aus Zp
    181           //  cout << "  beta["<<i << "] = " << beta[i];
    182         }
    183 
    184 
    185 
    186 
    187 
    188       Array<REvaluation> xi( 1, N );
    189       REvaluation a( 2, s-1, gen  );
    190 
    191       for ( i = 1 ; i <= N ; i++ )
    192         {
    193           a.nextpoint();
    194           xi[ i ] = a;//REvaluation( 2, s-1, gen );
    195           // cout << "  xi["<<i<<"] = "<< xi[i];
    196         }
    197 
    198 
    199       //CFArray T(1, d*N );
    200 
    201       if ( d == 0 )
    202         {
    203           ASSERT( 0, "alpha bad point! try some other gcd algorithm" );
    204           return gcd(u, v);
    205         }
    206 
    207       CFMatrix T( d, N ) ;  // diese Moeglichkeit laeuft!!!
    208                     //help = Koeff( T( j, k ), emma[ i ] );
    209                     //tau[i][j][k] = help; //.intval();
    210 
    211 
    212 
    213       for ( j = 1 ; j <= d ; j++ ) // jedesmal andere REvaluation??
    214         for ( k = 1 ; k <= N ; k++ )
    215           {
    216             CanonicalForm zwischenu, zwischenv, help, nfa ;
    217 
    218             zwischenu = U[ s ]( beta[ j ], s );
    219             zwischenv = V[ s ]( beta[ j ], s );
    220 
    221             T( j, k) = gcd ( xi[k]( zwischenu, 2, s-1 ), xi[k]( zwischenv, 2, s-1 ));
    222 
    223 
    224             nfa = lcggt( beta[j], s );
    225             nfa =  alpha( nfa, s+1, levU );
    226 
    227             //T(j, k ) = (xi[k]( nfa, 2, s-1 ))*((1/lc(T( j, k ))) * T( j, k ));
    228             T(j, k ) = (xi[k]( nfa, 2, s-1 ))*((1/Leitkoeffizient(T( j, k ))) * T( j, k ));
    229 
    230             //cout <<"T("<<j<<", "<< k <<") = " << T(j, k) << endl;
    231 
    232 
    233             for ( i = 1 ; i <= m ; i++ )
    234               {
    235                 // diese Moeglichkeit laeuft!!!
    236                 //help = Koeff( T( j, k ), emma[ i ] );
    237                 //tau[i][j][k] = help; //.intval();
    238                 if ( T( j, k).inBaseDomain() )
    239                   {
    240                     if ( emma[i] == 0 )
    241                       tau[i][j][k] = T( j, k );
    242                     else
    243                       tau[i][j][k] =  0 ;
    244                   }
    245                 else
    246                   {
    247                     tau[i][j][k] = T(j, k)[emma[i]];
    248                   }
    249               }
    250           }
    251 
    252 
    253       CFMatrix h( m, d );
    254 
    255 
    256       for ( i = 1; i <= m ; i++ )
    257         {
    258           for ( j = 1 ; j <= d ; j++ )
    259             {
    260               zip = n[i] +1;
    261               CanonicalForm * zwischen = new CanonicalForm[ zip ];//n[i]+1 ];
    262 
    263               for ( k = 1 ; k <= n[i] ; k++ )
    264                 {
    265                   zwischen[ k ] = tau[i][j][k];
    266                 }
    267 
    268               //cout <<" werte fuer sinterpol : " << endl;
    269               //cout <<" g["<<i<<"] = " << g[i] << " xi = " << xi << endl;
    270               //cout << " zwischen = " << zwischen << " ni = " << n[i]<<endl;
    271               h[ i ][ j ] = sinterpol( g[i], xi, zwischen, n[i] );
    272               DEBOUTLN( cerr, " Ergebnis von sinterpol h["<<i<<"]["<<j<< "] = " << h[i][j] );
    273               delete [] zwischen;
    274             }
    275         }
     229      {
     230        for ( j = 1 ; j <= d ; j++ )
     231        {
     232          zip = n[i] +1;
     233          CanonicalForm * zwischen = new CanonicalForm[ zip ];//n[i]+1 ];
     234
     235          for ( k = 1 ; k <= n[i] ; k++ )
     236          {
     237            zwischen[ k ] = tau[i][j][k];
     238          }
     239
     240          //cout <<" werte fuer sinterpol : " << endl;
     241          //cout <<" g["<<i<<"] = " << g[i] << " xi = " << xi << endl;
     242          //cout << " zwischen = " << zwischen << " ni = " << n[i]<<endl;
     243          h[ i ][ j ] = sinterpol( g[i], xi, zwischen, n[i] );
     244          DEBOUTLN( cerr, " Ergebnis von sinterpol h["<<i<<"]["<<j<< "] = " << h[i][j] );
     245          delete [] zwischen;
     246        }
     247      }
    276248      for ( i = 1 ; i <= m ; i++ )
    277         {
    278           CFArray zwitscher( 1, d );
    279           for ( j = 1 ; j <= d ; j++ )
    280             {
    281               zwitscher[ j ] = h[ i ][ j ];
    282             }
    283 
    284           DEBOUTLN( cerr, "Werte fuer dinterpol : " );
    285           DEBOUTLN( cerr, " d = " << d << " g["<<i<<"] = "<< g[i] );
    286           DEBOUTLN( cerr, " zwitscher = " << zwitscher );
    287           DEBOUTLN( cerr, " alpha["<<s<< "] = "<< alpha[s] << " beta = "<<beta << " n["<<i<<"] = " << n[i] );
    288 
    289           g[ i ] = dinterpol( d, g[i], zwitscher, alpha, s, beta, n[ i ], CHAR );
    290           DEBOUTLN( cerr, " Ergebnis von dinterpol g["<<i<<"] = " << g[i] );
    291 
    292         }
    293 
     249      {
     250        CFArray zwitscher( 1, d );
     251        for ( j = 1 ; j <= d ; j++ )
     252        {
     253          zwitscher[ j ] = h[ i ][ j ];
     254        }
     255
     256        DEBOUTLN( cerr, "Werte fuer dinterpol : " );
     257        DEBOUTLN( cerr, " d = " << d << " g["<<i<<"] = "<< g[i] );
     258        DEBOUTLN( cerr, " zwitscher = " << zwitscher );
     259        DEBOUTLN( cerr, " alpha["<<s<< "] = "<< alpha[s] << " beta = "<<beta << " n["<<i<<"] = " << n[i] );
     260
     261        g[ i ] = dinterpol( d, g[i], zwitscher, alpha, s, beta, n[ i ], CHAR );
     262        DEBOUTLN( cerr, " Ergebnis von dinterpol g["<<i<<"] = " << g[i] );
     263
     264      }
    294265
    295266      for ( i = 1 ; i <= m ; i++ )
    296         {
    297           G[ s ] += g[ i ] * ( power( x, emma[i] ) );
    298         }
     267      {
     268        G[ s ] += g[ i ] * ( power( x, emma[i] ) );
     269      }
    299270      DEBOUTLN( cerr, "G["<<s<<"] = " << G[s] );
    300       for ( i = 1; i <= m; i++ ) {
    301         for ( j = 1; j <= d; j++ )
    302           delete [] tau[i][j];
    303         delete [] tau[i];
     271      for ( i = 1; i <= m; i++ )
     272      {
     273        for ( j = 1; j <= d; j++ )
     274          delete [] tau[i][j];
     275        delete [] tau[i];
    304276      }
    305277      delete [] tau;
    306278    }
     279  }
    307280  delete [] emma;
    308281
    … …  
    318291  //cout << " in sparse " << endl;
    319292  if( F.inCoeffDomain() &&  G.inCoeffDomain() )
    320     {
    321       return gcd( F, G );
    322     }
     293  {
     294    return gcd( F, G );
     295  }
    323296
    324297  CanonicalForm f, g, ff, gg, ggt, res, fmodp, gmodp ;
    … …  
    326299
    327300  //   COMPRESS    ///////////////////
    328 
    329301
    330302  CFArray A(1, 2);
    … …  
    336308  g = M(A[2]);
    337309
    338 
    339310  // POLYNOME PRIMITIV BZGL DER ERSTEN VARIABLE  /////
    340 
    341 
    342311
    343312  CanonicalForm primif, primig, lcf, lcg, lcggt, lcggtmodp, result ;
    … …  
    345314  gg = content( g, Variable(1) );//contentsparse( g, 1  );
    346315
    347 
    348 
    349316  primif = f/ff;
    350317  primig = g/gg;
    … …  
    352319
    353320  if( primif.inCoeffDomain() &&  primig.inCoeffDomain() )
    354     {
    355       return N( gcd( primif, primig ) ) * N( ggt );
    356     }
    357 
    358 
    359 
     321  {
     322    return N( gcd( primif, primig ) ) * N( ggt );
     323  }
    360324
    361325  // Variablen, die in beiden Polynomen auftreten /////
    … …  
    380344
    381345  while ( ABFRAGE == 1 )
    382     {
    383       levelprimif = level(primif);
    384       levelprimig = level(primig);
    385 
    386       if ( levelprimif > levelprimig )
    387         levis = levelprimif;
    388       else
    389         levis = levelprimig;
    390 
    391       if ( levis < 0 )
    392         return N( gcd(primif, primig ));
    393 
    394 
    395       for( i = 1; i <= levis ; i++ )
    396         {
    397           if ( degree( primif, i ) != 0 )
    398             varf[i] = 1;
    399           else
    400             varf[i] = 0;
    401           if ( degree( primig, i ) != 0 )
    402             varg[i] = 1;
    403           else
    404             varg[i] = 0;
    405           if ( varg[i] == 1 && varf[i] == 1 )
    406             schnitt[i] = 1;
    407           else
    408             schnitt[i] = 0;
    409         }
    410 
    411       levelprimif = level(primif);
    412       levelprimig = level(primig);
    413 
    414       for ( m  = 1; m <= levis ; m++)
    415         {
    416           if ( schnitt[m] == 0 )
    417             if ( varf[m] == 1)
    418               {
    419                 primif = content( primif, m ); //contentsparse( primif, m  );
    420               }
    421             else
    422               {
    423                 primig = content( primig, m ); //contentsparse( primig, m  );
    424               }
    425         }
    426 
    427       if ( level( primif ) == level( primig ) )
    428         ABFRAGE = 0 ;
    429 
    430     }
    431 
    432  
     346  {
     347    levelprimif = level(primif);
     348    levelprimig = level(primig);
     349
     350    if ( levelprimif > levelprimig )
     351      levis = levelprimif;
     352    else
     353      levis = levelprimig;
     354
     355    if ( levis < 0 )
     356      return N( gcd(primif, primig ));
     357
     358    for( i = 1; i <= levis ; i++ )
     359    {
     360      if ( degree( primif, i ) != 0 )
     361        varf[i] = 1;
     362      else
     363        varf[i] = 0;
     364      if ( degree( primig, i ) != 0 )
     365        varg[i] = 1;
     366      else
     367        varg[i] = 0;
     368      if ( varg[i] == 1 && varf[i] == 1 )
     369        schnitt[i] = 1;
     370      else
     371        schnitt[i] = 0;
     372    }
     373
     374    levelprimif = level(primif);
     375    levelprimig = level(primig);
     376
     377    for ( m  = 1; m <= levis ; m++)
     378    {
     379      if ( schnitt[m] == 0 )
     380      {
     381        if ( varf[m] == 1)
     382        {
     383          primif = content( primif, m ); //contentsparse( primif, m  );
     384        }
     385        else
     386        {
     387          primig = content( primig, m ); //contentsparse( primig, m  );
     388        }
     389      }
     390    }
     391
     392    if ( level( primif ) == level( primig ) )
     393      ABFRAGE = 0 ;
     394
     395  }
     396
    433397  delete [] varf; delete [] varg; delete [] schnitt;
    434398
    435 
    436399  //  Nochmal compress fuer den Fall, dass eine Variable rausfliegt //
    437 
    438400
    439401  CFArray C(1, 2);
    … …  
    452414
    453415  if( primif.inCoeffDomain() &&  primig.inCoeffDomain() )
    454     {
    455       return N( NN( gcd( primif, primig ) ) ) * N( ggt );
    456     }
     416  {
     417    return N( NN( gcd( primif, primig ) ) ) * N( ggt );
     418  }
    457419
    458420  // erst hier Leitkoeffizienten updaten  /////////
    … …  
    463425  lcg = LC(primig, 1 );
    464426  lcggt = gcd ( lcf, lcg );
    465 
    466 
    467427
    468428  //   BOUND BESTIMMEN fuer Charakteristik Null   /////////
    … …  
    482442
    483443  if( CHAR == 0 )
    484     {
    485       p[ 1 ]  = cf_getBigPrime( count );
    486       CanonicalForm q = p[ 1 ];
    487 
    488       while ( q < Bound )
    489         {
    490           count++;
    491           length++;
    492           p[ length ] = cf_getBigPrime( count );
    493           q     *= p[ length ];  //G[levU] = ( 1/lc(G[levU] ))* G[levU];// sinnig?
    494     //cout << " lcggt = " << lcggt << endl;
    495     //bool ja;
    496     //ja = divides( lcggt, lc( G[levU] ) );
    497     //cout << " ja = " << ja << endl;
    498     //cout << " vor Verlassen " << endl;
    499         }
    500     }
     444  {
     445    p[ 1 ]  = cf_getBigPrime( count );
     446    CanonicalForm q = p[ 1 ];
     447
     448    while ( q < Bound )
     449    {
     450      count++;
     451      length++;
     452      p[ length ] = cf_getBigPrime( count );
     453      q     *= p[ length ];  //G[levU] = ( 1/lc(G[levU] ))* G[levU];// sinnig?
     454      //cout << " lcggt = " << lcggt << endl;
     455      //bool ja;
     456      //ja = divides( lcggt, lc( G[levU] ) );
     457      //cout << " ja = " << ja << endl;
     458      //cout << " vor Verlassen " << endl;
     459    }
     460  }
    501461  else
    502     {
    503       //int q  = CHAR;
    504       //setCharacteristic( 0 );
    505       //CanonicalForm Bound2 = mapinto( Bound ) ;
    506       //cout << " Bound2 " << Bound2 << endl;
    507       //cout << " CHAR =  " << q << endl;
    508 
    509       // erstmal ohne Erweiterung !!!
    510       //deg = 3; // Default Erweiterung
    511       //q *= ( q * q ) ;cout << "q = " << q << endl;
    512 
    513       //Bestimme Grad der Koerpererweiterung voellig unnuetz!!!
    514       //while ( q < abs( Bound2 ) )
    515       //        {
    516       //  q *= CHAR;cout << " q = " << q << endl;
    517       //deg++;cout << " degchar = " << deg << endl;
    518       //cout << " in Graderhoehung? " << endl;
    519 
    520       //}
    521       //setCharacteristic( CHAR );
    522       //cerr << " JUHU " << endl;
    523     }
    524 
    525 
    526 
     462  {
     463    //int q  = CHAR;
     464    //setCharacteristic( 0 );
     465    //CanonicalForm Bound2 = mapinto( Bound ) ;
     466    //cout << " Bound2 " << Bound2 << endl;
     467    //cout << " CHAR =  " << q << endl;
     468
     469    // erstmal ohne Erweiterung !!!
     470    //deg = 3; // Default Erweiterung
     471    //q *= ( q * q ) ;cout << "q = " << q << endl;
     472
     473    //Bestimme Grad der Koerpererweiterung voellig unnuetz!!!
     474    //while ( q < abs( Bound2 ) )
     475    //        {
     476    //  q *= CHAR;cout << " q = " << q << endl;
     477    //deg++;cout << " degchar = " << deg << endl;
     478    //cout << " in Graderhoehung? " << endl;
     479
     480    //}
     481    //setCharacteristic( CHAR );
     482    //cerr << " JUHU " << endl;
     483  }
    527484
    528485  //        ENDE BOUNDBESTIMMUNG       /////////////////
    529 
    530486
    531487  FFRandom gen ;
    … …  
    540496
    541497  for ( i = 1 ; i <= 10; i++ )               // 10 Versuche mit sparsemod
    542     {
    543       if ( CHAR == 0 )
    544         {
    545           for( k = 1; k <= length ; k++)
    546             {
    547               help = p[ k ].intval();
    548               setCharacteristic( help );
    549               FFRandom mache;
    550               am = REvaluation( 2, levelprimif, mache  );
    551               am.nextpoint();
    552               fmodp  = mapinto( primif );
    553               gmodp = mapinto( primig );
    554               lcggtmodp = mapinto ( lcggt );
    555 
    556               zwischen = smodgcd( fmodp, gmodp, lcggtmodp, am, mache, CHAR, Variable( 1 ));
    557               // Variable ( 1 ) Interface fuer endliche Koerper
    558 
    559               // Char auf 0 wegen Chinese Remainder ////////
    560 
    561               setCharacteristic( 0 );
    562 
    563 
    564               resultat[ k ] = mapinto( zwischen );
    565 
    566             }
    567 
    568 
    569           ////////////////////////////////////////////////////////////
    570           // result[k] mod p[k] via Chinese Remainder zu Resultat //////
    571           // ueber Z hochziehen                                //////
    572           ////////////////////////////////////////////////////////////
    573 
    574           if( length != 1 )
    575             ChinesePoly( length, resultat, p, result );
    576           else
    577             result = resultat[1];
    578 
    579           CanonicalForm contentresult = content( result, 1 );
    580 
    581           if ( contentresult != 0 )
    582             res = result/contentresult;
    583           else
    584             res = result;
    585 
    586           if ( divides( res, primif ) && divides( res, primig ) )
    587             return  N(NN(res))*N(ggt) ;     /// compress rueckgaengig machen!
    588           else
    589             {
    590 
    591               // Start all over again ///
    592 
    593               count++;
    594               for ( k = 1; k <= length ; k++)
    595                 {
    596                   p[k] = cf_getBigPrime( count );
    597                   count++;
    598                 }
    599 
    600             }
    601         }
    602       else
    603         {
    604           // Fall Char != 0 ///
    605           // in algebraische Erweiterung vom Grad deg gehen //
    606           //cout << " IN CHAR != 0 " << endl;
    607           //cout << " degree = " << deg << endl;
    608           CanonicalForm minimalpoly;
    609           //cout << " vor mini " << endl;
    610           minimalpoly = find_irreducible( deg, gen, alpha1 );
    611           //cout << " nach mini " << endl;
    612           Variable alpha2 = rootOf( minimalpoly, 'a' ) ;
    613           AlgExtRandomF hallo( alpha2 );
    614           //cout << " vor am " << endl;
    615           REvaluation am (  2, levelprimif, hallo );
    616           //cout << " nach ma " << endl;
    617           am.nextpoint();
    618           //cout << "vor smodgcd " << endl;
    619           result = smodgcd( primif, primig, lcggt, am, hallo, CHAR, alpha2  );
    620           if ( result == 1 && ABFRAGE == 0)
    621             {
    622               // zwei Auswertungen fuer gcd Eins
    623               am.nextpoint();
    624               ABFRAGE = 1;
    625             }
    626           //CanonicalForm contentresult = contentsparse(  result, 1 );
    627           //zuerst mal auf Nummer sicher gehen ...
    628           else
    629             {
    630               CanonicalForm contentresult = content(  result, 1 );
    631               //cout << "RESULT = " << result << endl;
    632               if ( contentresult != 0 )
    633                 res = result/contentresult;
    634               else
    635                 {
    636                   res = result;
    637                 }
    638 
    639 
    640               if ( ( divides( res, primif )) && ( divides ( res, primig ) ))
    641                 {
    642                   // make monic ////
    643                   res = (1/lc(res)) * res;
    644                   // eventuell auch hier Leitkoeffizient anstatt lc ?
    645 
    646                   return  N( NN( res ) ) * N( ggt ) ;
    647                 }
    648               else
    649                 {
    650                   // Grad der Erweiterung sukzessive um eins erhoehen
    651                   deg++;
    652                   //cout << " deg = " << deg << endl;
    653                   am.nextpoint();
    654                   // nextpoint() unnoetig?
    655                 }
    656             }
    657         }
    658     }
     498  {
     499    if ( CHAR == 0 )
     500    {
     501      for( k = 1; k <= length ; k++)
     502      {
     503        help = p[ k ].intval();
     504        setCharacteristic( help );
     505        FFRandom mache;
     506        am = REvaluation( 2, levelprimif, mache  );
     507        am.nextpoint();
     508        fmodp  = mapinto( primif );
     509        gmodp = mapinto( primig );
     510        lcggtmodp = mapinto ( lcggt );
     511
     512        zwischen = smodgcd( fmodp, gmodp, lcggtmodp, am, mache, CHAR, Variable( 1 ));
     513        // Variable ( 1 ) Interface fuer endliche Koerper
     514
     515        // Char auf 0 wegen Chinese Remainder ////////
     516
     517        setCharacteristic( 0 );
     518
     519        resultat[ k ] = mapinto( zwischen );
     520      }
     521
     522      ////////////////////////////////////////////////////////////
     523      // result[k] mod p[k] via Chinese Remainder zu Resultat //////
     524      // ueber Z hochziehen                                //////
     525      ////////////////////////////////////////////////////////////
     526
     527      if( length != 1 )
     528        ChinesePoly( length, resultat, p, result );
     529      else
     530        result = resultat[1];
     531
     532      CanonicalForm contentresult = content( result, 1 );
     533
     534      if ( contentresult != 0 )
     535        res = result/contentresult;
     536      else
     537        res = result;
     538
     539      if ( divides( res, primif ) && divides( res, primig ) )
     540        return  N(NN(res))*N(ggt) ;     /// compress rueckgaengig machen!
     541      else
     542      {
     543
     544        // Start all over again ///
     545
     546        count++;
     547        for ( k = 1; k <= length ; k++)
     548        {
     549          p[k] = cf_getBigPrime( count );
     550          count++;
     551        }
     552      }
     553    }
     554    else
     555    {
     556      // Fall Char != 0 ///
     557      // in algebraische Erweiterung vom Grad deg gehen //
     558      //cout << " IN CHAR != 0 " << endl;
     559      //cout << " degree = " << deg << endl;
     560      CanonicalForm minimalpoly;
     561      //cout << " vor mini " << endl;
     562      minimalpoly = find_irreducible( deg, gen, alpha1 );
     563      //cout << " nach mini " << endl;
     564      Variable alpha2 = rootOf( minimalpoly, 'a' ) ;
     565      AlgExtRandomF hallo( alpha2 );
     566      //cout << " vor am " << endl;
     567      REvaluation am (  2, levelprimif, hallo );
     568      //cout << " nach ma " << endl;
     569      am.nextpoint();
     570      //cout << "vor smodgcd " << endl;
     571      result = smodgcd( primif, primig, lcggt, am, hallo, CHAR, alpha2  );
     572      if ( result == 1 && ABFRAGE == 0)
     573      {
     574        // zwei Auswertungen fuer gcd Eins
     575        am.nextpoint();
     576        ABFRAGE = 1;
     577      }
     578      //CanonicalForm contentresult = contentsparse(  result, 1 );
     579      //zuerst mal auf Nummer sicher gehen ...
     580      else
     581      {
     582        CanonicalForm contentresult = content(  result, 1 );
     583        //cout << "RESULT = " << result << endl;
     584        if ( contentresult != 0 )
     585          res = result/contentresult;
     586        else
     587          res = result;
     588
     589        if ( ( divides( res, primif )) && ( divides ( res, primig ) ))
     590        {
     591          // make monic ////
     592          res = (1/lc(res)) * res;
     593          // eventuell auch hier Leitkoeffizient anstatt lc ?
     594
     595          return  N( NN( res ) ) * N( ggt ) ;
     596        }
     597        else
     598        {
     599          // Grad der Erweiterung sukzessive um eins erhoehen
     600          deg++;
     601          //cout << " deg = " << deg << endl;
     602          am.nextpoint();
     603          // nextpoint() unnoetig?
     604        }
     605      }
     606    }
     607  }
    659608
    660609
    … …  
    667616
    668617  return 0;
    669 
    670618}
    671619
Note: See TracChangeset for help on using the changeset viewer.