Changeset f90180 in git


Ignore:
Timestamp:
Apr 20, 2015, 11:01:28 AM (8 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '8d54773d6c9e2f1d2593a28bc68b7eeab54ed529')
Children:
9fce789c50beb6e5e309f48b6b7f2ce7e57597ae
Parents:
f52bd59412a399cb6c4ca21c965dd68c19aa5def
Message:
fix: int division (tr. #372), fix tr. #366
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/classify.lib

    rf52bd59 rf90180  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="version classify.lib 4.0.0.0 Jun_2013 "; // $Id$
     2version="version classify.lib 4.0.2.0 Apr_2015 "; // $Id$
    33category="Singularities";
    44info="
    … …  
    4646  link l="DBM:r NFlist";
    4747  s = read(l,"VERSION");
    48   if (s == "" ) {
     48  if (s == "" )
     49  {
    4950    if (printlevel > 0)
    5051    {
    … …  
    101102
    102103  v = Klassifiziere(conv_ext2top(f_in));
    103   if(typeof(v[1])=="poly") {
     104  if(typeof(v[1])=="poly")
     105  {
    104106     poly f_out = v[1];
    105107     s2 = v[2];          // s2: Typ des Polynoms f z.b: E[18]
    106108     corank = v[3];
    107109  }
    108   else {
     110  else
     111  {
    109112     s2="NoClass";
    110113  }
    111114
    112115//---------------- collect results and create return-value --------------------
    113   if( s2=="error!" || s2=="NoClass") {
     116  if( s2=="error!" || s2=="NoClass")
     117  {
    114118      setring ring_ext;
    115119      return(f_in);
    116120  }
    117121
    118   if(show_nf==1) {
     122  if(show_nf==1)
     123  {
    119124    poly f_nf = normalform(s2);
    120125    for(i=corank+1;i<=n;i=i+1) { f_nf = f_nf + x(i)^2; }
    … …  
    233238
    234239//-------------------- apply morsesplit if n>corank ---------------------------
    235    if( n > corank) {
     240   if( n > corank)
     241   {
    236242     debug_log(0,
    237243      "I have to apply the splitting lemma. This will take some time....:-)");
    … …  
    256262     setring ring_rest;
    257263   }
    258    else {
     264   else
     265   {
    259266     ring ring_rest=char(basering),(x(1..corank)),(c,ds);
    260267     map  PhiG=ring_top,maxideal(1);
    … …  
    266273    cstn[4] = phi;
    267274    if(corank == 2) { v_class = Funktion3(G, cstn); }
    268     else {
     275    else
     276    {
    269277      if(corank == 3) { v_class = Funktion50(G, cstn); }
    270278      else { v_class = printresult(1, f, "error!", cstn, -1); }
    271279    }
    272280//-------------------------- classification done ------------------------------
    273     if(typeof(v_class[1])!="poly") {
    274        return(v);
    275     }
     281    if(typeof(v_class[1])!="poly") { return(v); }
    276282    poly f_result = v_class[1];
    277283    v[2] = v_class[2];
    … …  
    304310    Mult = mult(Jf);
    305311    Mu = cstn[2];
    306     if(Dim == 1) {
     312    if(Dim == 1)
     313    {
    307314      if( Mult == 1) { return(printresult(5,f,"D["+string(Mu)+"]", cstn, 0)); }
    308315      if( Mult == 2) { return(Funktion6(f, cstn));}         // series E,J
    … …  
    343350
    344351//---------------------------- begin of loop ----------------------------------
    345     while( (6*k) <= Mu ) {
     352    while( (6*k) <= Mu )
     353    {
    346354      JetId = x(1)^3+x(2)^(3*k);
    347355      fk    = jet(f, 3*k, weight(JetId));
    348356      //--------------------------- step 6(k) ---------------------------------
    349       if( fk == Coeff(fk,x(1), x(1)^3)*x(1)^3 ) {
     357      if( fk == Coeff(fk,x(1), x(1)^3)*x(1)^3 )
     358      {
    350359        JetId = x(1)^3+x(2)^(3*k+1);           // check jet x3,y3k+1  : E[6k]
    351360        fk    = jet(f, 3*(3*k+1), weight(JetId));
    352         if( Coeff(fk,x(2),x(2)^(3*k+1)) != 0 ) {
     361        if( Coeff(fk,x(2),x(2)^(3*k+1)) != 0 )
     362        {
    353363          return(printresult(7, f, "E["+string(6*k)+"]", cstn, k-1));
    354364        }
    … …  
    356366        JetId = x(1)^3+x(1)*x(2)^(2*k+1);      // check jet x3,xy2k+1 : E[6k+1]
    357367        fk    = jet(f, 3*(2*k+1), weight(JetId));
    358         if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(2*k+1)) != 0 ) {
     368        if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(2*k+1)) != 0 )
     369        {
    359370          return(printresult(8, f,"E["+string(6*k+1)+"]", cstn, k-1));
    360371        }
    … …  
    362373        JetId = x(1)^3+x(2)^(3*k+2);           // check jet x3,y3k+1  : E[6k+2]
    363374        fk    = jet(f, 3*(3*k+2), weight(JetId));
    364         if( Coeff(fk,x(2),x(2)^(3*k+2)) != 0 ) {
     375        if( Coeff(fk,x(2),x(2)^(3*k+2)) != 0 )
     376        {
    365377          return(printresult(9, f,"E["+string(6*k+2)+"]", cstn, k-1));
    366378        }
    … …  
    375387        if(Dim==0) { return(printresult(11,f,"J["+string(k)+",0]",cstn,k-1)); }
    376388        Mult = mult(Jf);
    377         if( Dim ==1  && Mult==1) {
     389        if( Dim ==1  && Mult==1)
     390        {
    378391          return(printresult(12,f,"J["+string(k)+","+string(Mu - 6*k +2)+"]",
    379392                 cstn, k-1));
    380393        }
    381         if( Dim == 1  && Mult == 2) {
    382           if(Coeff(fk, x(2), x(2)^(3*k)) != 0) {
     394        if( Dim == 1  && Mult == 2)
     395        {
     396          if(Coeff(fk, x(2), x(2)^(3*k)) != 0)
     397          {
    383398            v    = Faktorisiere(f, fk, 3, k, RFlg);
    384399            f    = v[1];
    … …  
    413428    if(Dim==0) { return(printresult(14,f,"X[9] = X[1,0] = T[2,4,4]",cstn,1)); }
    414429    Mult = mult(Jf);
    415     if( Dim == 1) {
    416       if( Mult == 1 ) {
     430    if( Dim == 1)
     431    {
     432      if( Mult == 1 )
     433      {
    417434        return(printresult(15, f,
    418435              "X[1,"+string(Mu-9)+"] = T[2,4,"+string(Mu-5)+"]", cstn, 1));
    419436      }
    420       if( Mult == 2 ) {
     437      if( Mult == 2 )
     438      {
    421439        Jf = Jf, jacob(Jf);
    422440        Jf = std(Jf);
    … …  
    449467
    450468//---------------------------- begin of loop ----------------------------------
    451     while( 3*p<= Mu) {
     469    while( 3*p<= Mu)
     470    {
    452471      debug_log(1, "         Step 18("+string(p)+")");
    453472      v   = Isomorphie_s17(f, fk, p, 1);
    … …  
    456475      cstn[4] = PhiG;
    457476
    458       if ( p>1) {
     477      if ( p>1)
     478      {
    459479        JetId = x(1)^3*x(2) + x(2)^(3*p);
    460480        fk = jet(f, 3*p, weight(JetId));
    … …  
    463483      JetId = x(1)^3*x(2) + x(2)^(3*p+2);     // check jet x3y,y3k+2  : Z[6p+5]
    464484      fk = jet(f, 3*(3*p+2), weight(JetId));
    465       if( Coeff(fk, x(2), x(2)^(3*p+2)) != 0) {
     485      if( Coeff(fk, x(2), x(2)^(3*p+2)) != 0)
     486      {
    466487        return(printresult(19,f, "Z["+string(6*p+5)+"]", cstn, p));
    467488      }
    … …  
    469490      JetId = x(1)^3*x(2)+x(1)*x(2)^(2*p+2);  // check jet x3y,xy2k+2 : Z[6p+6]
    470491      fk = jet(f, 2*(3*p+2)+1, weight(JetId));
    471       if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(2*p+2)) != 0) {
     492      if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(2*p+2)) != 0)
     493      {
    472494        return(printresult(20, f, "Z["+string(6*p+6)+"]", cstn, p));
    473495      }
    … …  
    475497      JetId = x(1)^3*x(2) + x(2)^(3*p+3);     // check jet x3y,y3k+3  : Z[6p+7]
    476498      fk = jet(f, 3*(3*p+3), weight(JetId));
    477       if( Coeff(fk, x(2), x(2)^(3*p+3)) != 0) {
     499      if( Coeff(fk, x(2), x(2)^(3*p+3)) != 0)
     500      {
    478501        return(printresult(21, f, "Z["+string(6*p+7)+"]", cstn, p));
    479502      }
    … …  
    488511      Mult = mult(Jf);
    489512      if(Dim==0) { return(printresult(23,f,"Z["+string(p-1)+",0]", cstn, p)); }
    490       if( Mult == 1 ) {
     513      if( Mult == 1 )
     514      {
    491515         return(printresult(24, f, "Z["+string(p-1)+","+string(Mu-3-6*p)+"]",
    492516                cstn, p));
    … …  
    517541
    518542//---------------------------- begin of loop ----------------------------------
    519     while (k<Mu) {
     543    while (k<Mu)
     544    {
    520545      v    =  Faktorisiere(f, fk, 4 , k, RFlg);
    521546      f, Phi  = v[1..2];
    … …  
    526551      JetId = x(1)^4 + x(2)^(4*k+1);          // check jet x4,y4k+1  : W[12k]
    527552      fk    = jet(f, 4*(4*k+1), weight(JetId));
    528       if( Coeff(fk, x(2), x(2)^(4*k+1)) != 0) {
     553      if( Coeff(fk, x(2), x(2)^(4*k+1)) != 0)
     554      {
    529555        return(printresult(27, f, "W["+string(12*k)+"]", cstn, 3*k-2));
    530556      }
    … …  
    532558      JetId = x(1)^4 + x(1)*x(2)^(3*k+1);     // check jet x4,xy3k+1 : W[12k+1]
    533559      fk    = jet(f, 4*(3*k+1), weight(JetId));
    534       if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(3*k+1)) != 0) {
     560      if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(3*k+1)) != 0)
     561      {
    535562        return(printresult(28, f, "W["+string(12*k+1)+"]", cstn, 3*k-2));
    536563      }
    … …  
    539566      JetId = x(1)^4 + x(2)^(4*k+2);
    540567      fk    = jet(f, 2*(4*k+2), weight(JetId));
    541       if( Coeff(fk, x(2), x(2)^(4*k+2)) != 0) {
     568      if( Coeff(fk, x(2), x(2)^(4*k+2)) != 0)
     569      {
    542570        Jf  = std(jacob(fk));
    543571        Dim = dim(Jf);
    544572        if(Dim==0) {return(printresult(30,f,"W["+string(k)+",0]",cstn,3*k-1));}
    545         if(Dim==1) {
     573        if(Dim==1)
     574        {
    546575           return(printresult(32, f,
    547576                  "W#["+string(k)+","+string(Mu-12*k-3)+"]", cstn, 3*k-1));
    … …  
    549578        return(printresult(29, f, "error!", cstn, -1));
    550579      }
    551       else {
     580      else
     581      {
    552582        // x^4 oder x^2(x^2+x(2)^2k+1)
    553583        ft  = Teile(fk, x(1)^2);
    554584        Jf  = std(jacob(ft));
    555585        Dim = dim(Jf);
    556         if( Dim == 0 ) {
     586        if( Dim == 0 )
     587        {
    557588           return(printresult(31, f, "W["+string(k)+","+string(Mu-12*k-3)+"]",
    558589                  cstn, 3*k-1));
    … …  
    563594        JetId = x(1)^4 + x(1)*x(2)^(3*k+2);   // check jet x4,xy3k+2 : W[12k+5]
    564595        fk    = jet(f, 4*(3*k+2), weight(JetId));
    565         if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(3*k+2)) != 0) {
     596        if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(3*k+2)) != 0)
     597        {
    566598          return(printresult(34, f,"W["+string(12*k+5)+"]", cstn, 3*k-1));
    567599        }
    … …  
    569601        JetId = x(1)^4 + x(2)^(4*k+3);        // check jet x4,y4k+3  : W[12k+6]
    570602        fk    = jet(f, 4*(4*k+3), weight(JetId));
    571         if( Coeff(fk, x(2), x(2)^(4*k+3)) != 0){
     603        if( Coeff(fk, x(2), x(2)^(4*k+3)) != 0)
     604        {
    572605          return(printresult(35, f,"W["+string(12*k+6)+"]", cstn, 3*k-1));
    573606        }
    … …  
    581614        Mult  = mult(Jf);
    582615        if(Dim==0) {return(printresult(37,f,"X["+string(k)+",0]",cstn,3*k-1));}
    583         if(Dim==1) {
    584           if(Mult==1) {
     616        if(Dim==1)
     617        {
     618          if(Mult==1)
     619          {
    585620             return(printresult(38, f,"X["+string(k)+","+string(Mu-12*k+3)+"]",
    586621                    cstn, 3*k-1));
    587622          }
    588           if(Mult==2) {
     623          if(Mult==2)
     624          {
    589625            ft  = Teile(fk, x(1)^2);
    590626            Jf  = std(jacob(ft));
    591627            Dim = dim(Jf);
    592628            if( Dim == 0) { return(Funktion40(f, cstn, k)); }
    593             if( Dim == 1) {
     629            if( Dim == 1)
     630            {
    594631               return(printresult(39, f, "Y["+string(k)+",r,s]", cstn,3*k-1));
    595632            }
    596633          }
    597           if(Mult!=3) {
     634          if(Mult!=3)
     635          {
    598636            return(printresult(36, f, "error!", cstn, -1)); }
    599637        }
    … …  
    638676    r   = kr-k;
    639677    setring ring_top;
    640     if( Typ == "E[6k]" ) {
     678    if( Typ == "E[6k]" )
     679    {
    641680       return(printresult(42, f, "Z["+string(k)+","+string(12*k+6*r-1)+"]",
    642681              cstn, 3*k+r-2));
    643682    }
    644     if( Typ == "E[6k+1]" ) {
     683    if( Typ == "E[6k+1]" )
     684    {
    645685       return(printresult(43, f, "Z["+string(k)+","+string(12*k+6*r)+"]",
    646686              cstn, 3*k+r-2));
    647687    }
    648     if( Typ == "E[6k+2]" ) {
     688    if( Typ == "E[6k+2]" )
     689    {
    649690       return(printresult(44, f, "Z["+string(k)+","+string(12*k+6*r+1)+"]",
    650691              cstn, 3*k+r-2));
    651692    }
    652     if( Typ == "J[k,0]" ) {
     693    if( Typ == "J[k,0]" )
     694    {
    653695       return(printresult(45, f, "Z["+string(k)+","+string(r)+",0]",
    654696              cstn, 3*k+r-2));
    655697    }
    656     if( Typ == "J[k,r]" ) {
     698    if( Typ == "J[k,r]" )
     699    {
    657700       return(printresult(46,f,"Z["+string(k)+","+string(r)+","+string(rr)+"]",
    658701              cstn, 3*k+r-2));
    … …  
    681724    Mu   = cstn[2];
    682725
    683     if(Dim == 0) {
     726    if(Dim == 0)
     727    {
    684728       return(printresult(51, f, "P[8] = T[3,3,3]", cstn, 1));
    685729    } // x3 + y3 + z3 + axyz
    686     if(Dim == 1) {
    687       if (Mult == 1) {
     730    if(Dim == 1)
     731    {
     732      if (Mult == 1)
     733      {
    688734        return(printresult(52, f,"P["+string(Mu)+"] = T[3,3,"+string(Mu-5)+"]",
    689735               cstn, 1));
    690736      } // x3 + y3 + xyz
    691       if(Mult == 2) {
     737      if(Mult == 2)
     738      {
    692739        Jf2 = wedge(jacob(Jf1),3-Dim), Jf1;
    693740        Jf2 = std(Jf2);
    … …  
    696743        if (Dim==1) { return(Funktion58(f, cstn)); }  // x3 + yz2
    697744      }
    698       if(Mult == 3) {
     745      if(Mult == 3)
     746      {
    699747        Jf2 = wedge(jacob(Jf1),3-Dim), Jf1;
    700748        Jf2 = std(Jf2);
    … …  
    705753      if(Mult == 4) { return(Funktion82(f, cstn)); }    // x3 + xz2
    706754    }
    707     if(Dim == 2) {
     755    if(Dim == 2)
     756    {
    708757      if(Mult == 1) { return(Funktion97(f, cstn)); }    // x2y
    709758      if(Mult == 2) { return(printresult(103,f,"NoClass", cstn, -1));}
    … …  
    758807
    759808    debug_log(6, "f3,s1=", Show(f3));
    760     if( b1 != 0) {
     809    if( b1 != 0)
     810    {
    761811      VERT=ring_top,-1*b1*x(1), -1*b2*x(1)+x(2), -1*b3*x(1) + x(3);
    762812      kx=1; ky=2; kz=3;
    763813    }
    764     else {
    765       if( b2 != 0) {
     814    else
     815    {
     816      if( b2 != 0)
     817      {
    766818        VERT=ring_top, x(1) + -1*b1*x(2), -1*b2*x(2), -1*b3*x(2) + x(3);
    767819        kx=2; ky=1; kz=3;
    768820      }
    769       else {
    770         if( b3 != 0) {
     821      else
     822      {
     823        if( b3 != 0)
     824        {
    771825          VERT=ring_top,x(1) + -1*b1*x(3), x(2) + -1*b2*x(3), -1*b3*x(3);
    772826          kx=3; ky=1; kz=2;
    … …  
    786840    fb=C[2,1];  // Coeff von x^1
    787841    fc=C[1,1];  // Coeff von x^0
    788     if(diff(fb, x(ky)) != 0) {
     842    if(diff(fb, x(ky)) != 0)
     843    {
    789844      Jfsyz = fb, diff(fb, x(ky));
    790845      matrix Mat = matrix(syz(Jfsyz));
    791846      B = maxideal(1);     // setze Abbildungs-ideal
    792       if( nrows(Mat) == 2) {
     847      if( nrows(Mat) == 2)
     848      {
    793849        poly Relation = -2 * Mat[2,1] / Mat[1,1];
    794850        b = Coeff(Relation, x(kz), x(kz));
    795851        B[rvar(x(ky))] = x(ky)-b*x(kz);
    796852      }
    797       else {
     853      else
     854      {
    798855        Jfsyz = fb, diff(fb, x(kz));
    799856        Mat = matrix(syz(Jfsyz));
    … …  
    827884    fc=(x(kx)-1*(Coeffs(fb,x(ky))[2,1])*x(ky)-1*(Coeffs(fb,x(kz))[2,1])*x(kz));
    828885    fa = Coeffs(fb, x(kx))[2,1];
    829     if ( fa != 0 ) {
     886    if ( fa != 0 )
     887    {
    830888      B = maxideal(1);
    831889      B[rvar(x(kx))] = fc / fa;
    … …  
    838896
    839897    //--------------------- permutation of x,y,z  -----------------------------
    840     if(Coeffs(f3, x(1))[4,1]!=0) {
     898    if(Coeffs(f3, x(1))[4,1]!=0)
     899    {
    841900      kx=1;
    842901      if(Coeffs(f3, x(2))[3,1]==0) { ky=2; kz=3; }
    843902      else { ky=3; kz=2; }
    844903    }
    845     else {
    846       if(Coeffs(f3, x(2))[4,1]!=0) {
     904    else
     905    {
     906      if(Coeffs(f3, x(2))[4,1]!=0)
     907      {
    847908        kx=2;
    848909        if(Coeffs(f3, x(3))[3,1]==0) { ky=3; kz=1; }
    849910        else { ky=1; kz=3; }
    850911      }
    851       else {
     912      else
     913      {
    852914        kx=3;
    853915        if(Coeffs(f3, x(1))[3,1]==0) { ky=1; kz=2; }
    … …  
    892954
    893955//---------------------------- begin of loop ----------------------------------
    894     while(6*p<Mu) {
     956    while(6*p<Mu)
     957    {
    895958      JetId = x(2)^(3*p+1);
    896959      JetId = phi + x(2)^(3*p+1);
    … …  
    919982      Mult  = mult(JetId);
    920983      if(Dim==0) { return(printresult(64, f, "Q["+string(p)+",0]", cstn, p)); }
    921       if(Dim==1) {
    922         if(Mult == 1) {
     984      if(Dim==1)
     985      {
     986        if(Mult == 1)
     987        {
    923988           return(printresult(65, f, "Q["+string(p)+","+string(Mu-(6*p+2))+"]",
    924989                  cstn, p));
    925990        }
    926         if(Mult == 2) {
     991        if(Mult == 2)
     992        {
    927993          fk    = jet(fr, 3*w[1], w);
    928994          f_tmp = Coeffs(phi, x(1))[4,1] *x(1)^3+fk;
    … …  
    9971063    if (diff(f3, x(3)) == 0) { kz, ky = swap(kz, ky); }
    9981064    if ( (diff(f3, x(1)) != 0) && (diff(f3, x(2)) != 0) &&
    999           (diff(f3, x(3)) != 0) ) {
     1065          (diff(f3, x(3)) != 0) )
     1066    {
    10001067      Mat = matrix(syz(Jfsyz));
    10011068      b1  = Mat[1,1];
    … …  
    10031070      b3  = Mat[3,1];
    10041071
    1005       if( b1 != 0) {
     1072      if( b1 != 0)
     1073      {
    10061074        VERT = ring_top,b1*x(kx), b2*x(kx)+x(ky), b3*x(kx) + x(kz);
    10071075        kx, ky = swap(kx, ky);
    10081076      }
    1009       else {
     1077      else
     1078      {
    10101079        if(b2!=0) { VERT = ring_top,x(kx)+b1*x(ky),b2*x(ky),b3*x(ky)+x(kz); }
    1011         else {
     1080        else
     1081        {
    10121082          if(b3!=0) { VERT = ring_top,x(kx)+b1*x(kz),x(ky)+b2*x(kz),b3*x(kz); }
    10131083          else { VERT = ring_top,B; }
    … …  
    10351105    if(C[1,1] != 0 && C[3,1] == 0 ) { Fall = 2; kx,kz=swap(kx, kz); }
    10361106
    1037     if(Fall == 1) {
     1107    if(Fall == 1)
     1108    {
    10381109      VERT=ring_top,x(kx),x(ky),x(kz);
    10391110    }
    1040     if(Fall == 2) {
     1111    if(Fall == 2)
     1112    {
    10411113       v = tschirnhaus(f3/x(kz), x(kx));
    10421114       b1, VERT = v[1..2];
    10431115    }
    1044     if(Fall == 3) {
     1116    if(Fall == 3)
     1117    {
    10451118      v = tschirnhaus(f3/x(kx), x(kx));
    10461119      b1, VERT = [1..2];
    … …  
    10571130//------------- if f3 ~ x3+xz2 then continue with classification  -------------
    10581131    C = coeffs(f3, x(1));
    1059     if( C[1,1] == 0 && C[2,1] != 0 && C[3,1] == 0 && C[4,1] != 0 ) {
     1132    if( C[1,1] == 0 && C[2,1] != 0 && C[3,1] == 0 && C[4,1] != 0 )
     1133    {
    10601134      return(Funktion83(f, cstn));
    10611135    }
    … …  
    11351209    PhiG = cstn[4];
    11361210//---------------------------- begin of loop ----------------------------------
    1137     while(k<10) {
     1211    while(k<10)
     1212    {
    11381213      phi   = jet(f, 3);
    11391214      //--------------------------- step 83(k) --------------------------------
    … …  
    11451220      fk    = jet(f, 3*w[1], weight(JetId)) ;
    11461221      //--------------------------- step 85(k) --------------------------------
    1147       if ( fk != phi ) {
     1222      if ( fk != phi )
     1223      {
    11481224        Jf   = std(jacob(fk));
    11491225        Dim  = dim(Jf);
    … …  
    11651241      Mult  = mult(Jf);
    11661242      if ( Dim == 0 ) { return(printresult(83, f, "NoClass", cstn, -1)); }
    1167       if ( Dim == 1 ) {
    1168         if ( Mult == 4 ) {
    1169           if( fk - phi != 0) { // b!=0  und/oder b'!=0
    1170             if( Coeff(fk,x(1)*x(2), x(1)^2*x(2)^k) == 0 ) { // b=0 und b'!=0
     1243      if ( Dim == 1 )
     1244      {
     1245        if ( Mult == 4 )
     1246        {
     1247          if( fk - phi != 0)
     1248          { // b!=0  und/oder b'!=0
     1249            if( Coeff(fk,x(1)*x(2), x(1)^2*x(2)^k) == 0 )
     1250            { // b=0 und b'!=0
    11711251              a    = (fk - Coeff(fk, x(1), x(1)^3)*x(1)^3) / x(1);
    11721252              v    = Isomorphie_s82_z(f, a, k);
    11731253            }
    1174             else {
    1175               if( Coeff(fk,x(1)*x(2)*x(3), x(1)*x(2)^k*x(3)) == 0 ){
     1254            else
     1255            {
     1256              if( Coeff(fk,x(1)*x(2)*x(3), x(1)*x(2)^k*x(3)) == 0 )
     1257              {
    11761258                        // b!=0 und b'=0
    11771259                a    = subst(fk, x(3), 0);
    11781260                v    = Isomorphie_s82_x(f, a, k);
    11791261              }
    1180               else {
     1262              else
     1263              {
    11811264                a = Coeff(fk,x(1)*x(2)*x(3), x(1)*x(2)^k*x(3));
    11821265                b = Coeff(fk,x(2)*x(3), x(2)^(2*k)*x(3));
    … …  
    12281311//--------------------------- compute f3 ~ x2y --------------------------------
    12291312    // vertausche 2 Koordinaten sodass d2f/dx2 <>0 ist.
    1230     for(i=1;i<4;i=i+1) {
     1313    for(i=1;i<4;i=i+1)
     1314    {
    12311315      if(diff(diff(f3, x(i)), x(i)) != 0) { kx = i; i=4; }
    12321316    }
    … …  
    12371321    Jfsyz = f3, diff(f3, x(kx));
    12381322    Mat   = matrix(syz(Jfsyz));
    1239     if(deg(Mat[2,1])>1) {
     1323    if(deg(Mat[2,1])>1)
     1324    {
    12401325      Jfsyz = f3, Mat[2,1];
    12411326      Mat   = matrix(syz(Jfsyz));
    … …  
    12801365    Mult  = mult(Jf);
    12811366    if( Dim == 0) { return(printresult(99, f, "V[1,0]", cstn, 3)); }
    1282     if( Dim == 1) {
     1367    if( Dim == 1)
     1368    {
    12831369      if(Mult==1) {return(printresult(100,f,"V[1,"+string(Mu-15)+"]",cstn,3));}
    12841370      if(Mult==2){return(printresult(101,f,"V#[1,"+string(Mu-15)+"]",cstn,3));}
    … …  
    13401426    debug_log(2, "Faktor: f=",Show(f)," Jet=",Show(fk)," k=",k, "cnt=", ct);
    13411427
    1342     if( k == 1) {
     1428    if( k == 1)
     1429    {
    13431430      Jfsyz = fk, diff(fk, x(1));
    13441431      Matx  = matrix(syz(Jfsyz));
    … …  
    13511438      d = Coeff(fk, x(1)*x(2), x(1)*x(2)^3);
    13521439
    1353       if( (a != 0) && (b != 0) ) {
     1440      if( (a != 0) && (b != 0) )
     1441      {
    13541442        B = -int(Coeff(Matx[1,1], x(2), x(2)));
    13551443        C = -int(Coeff(Maty[1,1], x(1), x(1)));
    … …  
    13581446        gamma = int(Coeff(Matx[2,1], x(2), x(2)^2));
    13591447
    1360         bb[rvar(x(1))] = x(1) - (2*gamma / (B - beta))*x(2);
    1361         bb[rvar(x(2))] = x(2) - ((C - beta) / (2*gamma))*x(1);
     1448        bb[rvar(x(1))] = x(1) - (2*number(gamma) / (B - beta))*x(2);
     1449        bb[rvar(x(2))] = x(2) - ((C - number(beta)) / (2*gamma))*x(1);
    13621450        VERT     = ring_top,bb;
    13631451        Relation = VERT(f);
    … …  
    13811469      }
    13821470
    1383       if( (a == 0) || (b == 0) ) {
    1384         if( a == 0) {
    1385           if( c == 0) { // y3(ax+by)
     1471      if( (a == 0) || (b == 0) )
     1472      {
     1473        if( a == 0)
     1474        {
     1475          if( c == 0)
     1476          { // y3(ax+by)
    13861477            Relation = - Matx[2,1] / Matx[1,1];
    13871478            a = Coeff(Relation, x(1), x(1));
    … …  
    13891480            VERT=ring_top,a*x(2)^k - b*x(1), x(1);
    13901481          }
    1391           else { // (ax+by)^3y
     1482          else
     1483          { // (ax+by)^3y
    13921484            Relation = - 3*Matx[2,1] / Matx[1,1];
    13931485            a = Coeff(Relation, x(1), x(1));
    … …  
    13961488          }
    13971489        }
    1398         else {
    1399           if( d == 0) { // x3(ax+by)
     1490        else
     1491        {
     1492          if( d == 0)
     1493          { // x3(ax+by)
    14001494            Relation = - Maty[2,1] / Maty[1,1];
    14011495            a = Coeff(Relation, x(1), x(1));
    … …  
    14031497            VERT=ring_top,x(1), b*x(2)^k - a*x(1);
    14041498          }
    1405           else { // x(ax+by)^3
     1499          else
     1500          { // x(ax+by)^3
    14061501            Relation = - 3*Maty[2,1] / Maty[1,1];
    14071502            a = Coeff(Relation, x(1), x(1));
    … …  
    14131508        PhiG = VERT(PhiG);
    14141509      }
    1415       else {  //      "Weder b noch a sind 0";
     1510      else
     1511      {  //      "Weder b noch a sind 0";
    14161512        if(ct > 5) { v[1]=f; v[2]=PhiG; return(v); }
    14171513        fk = jet(f, 4);
    … …  
    14191515      }
    14201516    }
    1421     else {  // k >1
     1517    else
     1518    {  // k >1
    14221519      a     = fk/x(2);
    14231520      Jfsyz = a, diff(a, x(1));
    … …  
    17631860  while( (i<=ncols(K)) && (K[1,i] != term) )
    17641861  { i++;
    1765     if(i>ncols(K)) { break; }
     1862    if(i>ncols(K)) break;
    17661863  }
    17671864  if(i<=ncols(K)) { a = K[2,i]; }
    … …  
    18121909  // check basic condition on the basering.
    18131910  if(checkring()) { return(f); }
    1814   if( f==0 ) {
     1911  if( f==0 )
     1912  {
    18151913    "Normal form : 0";
    18161914    return(f);
    18171915  }
    1818   if( jet(f,0)!=0 ) {
     1916  if( jet(f,0)!=0 )
     1917  {
    18191918    "Normal form : 1";
    18201919    return(f);
    18211920  }
    18221921  K, Mu, corank = basicinvariants(f);
    1823   if(Mu<0) {
     1922  if(Mu<0)
     1923  {
    18241924    debug_log(0, "The Milnor number of the function is infinite.");
    18251925    return(f);
    … …  
    18321932  Typ, cnt = v[1..2];
    18331933  "Singularity R-equivalent to :",Typ;
    1834   if(cnt==0) {
     1934  if(cnt==0)
     1935  {
    18351936    "Hilbert polynomial not recognised. Milnor code = ", milnorcode(f);
    18361937    return();
    18371938  }
    1838   if(cnt==1) {
     1939  if(cnt==1)
     1940  {
    18391941    debug_log(1,"Getting normal form from database.");
    18401942    "normal form :",A_L(Typ);
    … …  
    19392041
    19402042  if(Dim == 0) { return("P[8]:smooth cubic"); } // x3 + y3 + z3 + axyz
    1941   if(Dim == 1) {
    1942     if(Mult == 2) {
     2043  if(Dim == 1)
     2044  {
     2045    if(Mult == 2)
     2046    {
    19432047      Jf2  = wedge(jacob(Jf1),3-Dim), Jf1;
    19442048      Jf2  = std(Jf2);
    … …  
    19472051      if (Dim == 1) { return("Q:cuspidal cubic"); }  // x3 + yz2
    19482052    }
    1949     if(Mult == 3) {
     2053    if(Mult == 3)
     2054    {
    19502055      Jf2 = wedge(jacob(Jf1),3-Dim), Jf1;
    19512056      Jf2 = std(Jf2);
    … …  
    19562061    if(Mult == 4) { return("U:three concurrent lines"); }       // x3 + xz2
    19572062  }
    1958   if(Dim == 2) {
     2063  if(Dim == 2)
     2064  {
    19592065    if(Mult == 1) { return("V:doubleline + line"); }    // x2y
    19602066    if(Mult == 2) { return("V': tripple line"); }       // x3
    … …  
    20122118  debug_log(2, "entering HKclass3_teil_1", sg);
    20132119  if(sg[2]==1) { SG_Typ=SG_Typ+" D[k]=D["+string(sg[3]+3)+"]";cnt++;} // D[k]
    2014   if(sg[2]>=1) {
    2015     if( parity(sg[2])) { // sg[2] ist ungerade
    2016       if(sg[2]<=sg[3]) {
     2120  if(sg[2]>=1)
     2121  {
     2122    if( parity(sg[2]))
     2123    { // sg[2] ist ungerade
     2124      if(sg[2]<=sg[3])
     2125      {
    20172126        k = (sg[2]+1) div 2;
    2018         if(k>1) {
     2127        if(k>1)
     2128        {
    20192129          cnt++;
    20202130          SG_Typ=SG_Typ+" J[k,r]=J["+string(k)+","+string(sg[3]+1-2*k)+"]";
    20212131        }// J[k,r]
    20222132      }
    2023       if(sg[2]==sg[3]+2) {                              // E[6k+2]
     2133      if(sg[2]==sg[3]+2)
     2134      {                              // E[6k+2]
    20242135        k = (sg[2]-1) div 2;
    20252136        if(k>0) {cnt++; SG_Typ=SG_Typ+" E[6k+2]=E[" + string(6*k+2) + "]"; }
    20262137      }
    20272138    }
    2028     else {              // sg[2] ist gerade
    2029       if( sg[2] == sg[3]+1) {                           // E[6k]
    2030         k = sg[2] div 2; cnt++; SG_Typ=SG_Typ + " E[6k]=E[" + string(6*k) + "]"; }
    2031       if( sg[2] == sg[3]) {                             // E[6k+1]
     2139    else
     2140    {              // sg[2] ist gerade
     2141      if( sg[2] == sg[3]+1)
     2142      {                           // E[6k]
     2143        k = sg[2] div 2; cnt++; SG_Typ=SG_Typ + " E[6k]=E[" + string(6*k) + "]";
     2144      }
     2145      if( sg[2] == sg[3])
     2146      {                             // E[6k+1]
    20322147        k=sg[2] div 2; cnt++; SG_Typ=SG_Typ+" E[6k+1]=E["+string(6*k+1)+"]"; }
    20332148    }
    … …  
    20582173
    20592174  debug_log(2, "entering HKclass5_teil_1", sg);
    2060   if(parity(sg[3])) {  // Dritte Stelle soll ungerade sein
     2175  if(parity(sg[3]))
     2176  {  // Dritte Stelle soll ungerade sein
    20612177    k = (sg[3]+1) div 2;
    2062     if(sg[3] > sg[4]) {
     2178    if(sg[3] > sg[4])
     2179    {
    20632180      k--;
    2064       if( (sg[4]==sg[5]) && (sg[3] == sg[4]+1) && k>0 ) { // W[12k+6]
     2181      if( (sg[4]==sg[5]) && (sg[3] == sg[4]+1) && k>0 )
     2182      { // W[12k+6]
    20652183        SG_Typ = SG_Typ + " W[12k+6]=W["+string(12*k+6)+"]"; cnt++;
    20662184      }
    2067       if( (sg[3]==sg[5]) && (sg[3] == sg[4]+2) && k>0 ) { // W[12k+5]
     2185      if( (sg[3]==sg[5]) && (sg[3] == sg[4]+2) && k>0 )
     2186      { // W[12k+5]
    20682187        SG_Typ = SG_Typ + " W[12k+5]=W["+string(12*k+5)+"]"; cnt++;
    20692188      }
    20702189    }
    2071     else {  // sg[3] <= sg[4]
    2072       if( (sg[3]==sg[4]) && (sg[5] >= sg[3]) ) {
     2190    else
     2191    {  // sg[3] <= sg[4]
     2192      if( (sg[3]==sg[4]) && (sg[5] >= sg[3]) )
     2193      {
    20732194        r = sg[5] - sg[4];
    20742195        SG_Typ=SG_Typ +" X[k,r]=X["+string(k)+","+string(r)+"]"; cnt++;
    20752196      }
    2076       if( (sg[3]==1) && (sg[4]==3) && (sg[5]>=sg[4])){    // Z[1,r]
     2197      if( (sg[3]==1) && (sg[4]==3) && (sg[5]>=sg[4]))
     2198      {    // Z[1,r]
    20772199        r = sg[5] - sg[4];
    20782200        SG_Typ = SG_Typ + " Z[1,r]=Z[1,"+string(r)+"]"; cnt++;
    20792201      }
    20802202
    2081       if( sg[4] == sg[5]) {
    2082         if(parity(sg[4])) {                                  // Z[k,r,0]
     2203      if( sg[4] == sg[5])
     2204      {
     2205        if(parity(sg[4]))
     2206        {                                  // Z[k,r,0]
    20832207          r = (sg[4] - sg[3]) div 2;
    2084           if( r>0 ) { cnt++;
     2208          if( r>0 )
     2209          { cnt++;
    20852210            SG_Typ = SG_Typ + " Z[k,r,0]=Z["+string(k)+","+string(r)+",0]";
    20862211          }
    20872212        }
    2088         else {                                                // Z[k,12k+6r]
     2213        else
     2214        {                                                // Z[k,12k+6r]
    20892215          r = (sg[4] - 2*k) div 2; cnt++;
    20902216          SG_Typ = SG_Typ+" Z[k,12k+6r]=Z["+string(k)+","+string(12*k+6*r)+"]";
    … …  
    20922218      }
    20932219
    2094       if( parity(sg[4]) ) {  // 4. Stelle ist ungerade
    2095         if(sg[4] == sg[5]+2) {                              // Z[k,12k+6r+1]
     2220      if( parity(sg[4]) )
     2221      {  // 4. Stelle ist ungerade
     2222        if(sg[4] == sg[5]+2)
     2223        {                              // Z[k,12k+6r+1]
    20962224          r = (sg[4]-2*k-1) div 2; cnt++;
    20972225          SG_Typ=SG_Typ+" Z[k,12k+6r+1]=Z["+string(k)+",";
    20982226          SG_Typ=SG_Typ+string(12*k+6*r+1)+"]";
    20992227       }
    2100        if( (sg[5]>sg[4]) && (sg[4]>sg[3]) ) {           // Z[k,r,s]
     2228       if( (sg[5]>sg[4]) && (sg[4]>sg[3]) )
     2229       {           // Z[k,r,s]
    21012230          r = (sg[4] - sg[3]) div 2; cnt++;
    21022231          s = sg[5] - sg[4];
    … …  
    21052234        }
    21062235      }
    2107       else {  // 4. Stelle ist gerade
    2108         if( sg[4] == sg[5]+1) {                             // Z[k,12k+6r-1]
     2236      else
     2237      {  // 4. Stelle ist gerade
     2238        if( sg[4] == sg[5]+1)
     2239        {                             // Z[k,12k+6r-1]
    21092240          r = (sg[4] - 2*k) div 2; cnt++;
    21102241          SG_Typ=SG_Typ+" Z[k,12k+6r-1]=Z["+string(k)+",";
    … …  
    21132244      }
    21142245
    2115       if(sg[4]>sg[3]) {                                     // Y[k,r,s]
     2246      if(sg[4]>sg[3])
     2247      {                                     // Y[k,r,s]
    21162248        r = sg[4] - sg[3];
    21172249        s = sg[5] - sg[3] + r;
    … …  
    21222254    }
    21232255  }
    2124   else {  // Dritte Stelle soll gerade sein
     2256  else
     2257  {  // Dritte Stelle soll gerade sein
    21252258    k = sg[3] div 2;
    21262259    // sortiere verschiedene W's
    2127     if(k>0) {
    2128       if( (sg[4]==2*k-1) && (sg[4]==sg[5]) ) {  // W[12k]
     2260    if(k>0)
     2261    {
     2262      if( (sg[4]==2*k-1) && (sg[4]==sg[5]) )
     2263      {  // W[12k]
    21292264        SG_Typ = SG_Typ + " W[12k]=W["+string(12*k)+"]"; cnt++;
    21302265      }
    2131       if( (sg[4]==2*k-1) && (sg[3]==sg[5]) ) {  // W[12k+1]
     2266      if( (sg[4]==2*k-1) && (sg[3]==sg[5]) )
     2267      {  // W[12k+1]
    21322268        SG_Typ = SG_Typ + " W[12k+1]=W["+string(12*k+1)+"]"; cnt++;
    21332269      }
    2134       if( (sg[4]==2*k) && (sg[5]>=sg[4]) ) {    // W[k,r]
     2270      if( (sg[4]==2*k) && (sg[5]>=sg[4]) )
     2271      {    // W[k,r]
    21352272        r = sg[5] - sg[4];
    21362273        SG_Typ=SG_Typ+" W[k,r]=W["+string(k)+","+string(r)+"]"; cnt++;
    21372274      }
    2138       if( (sg[5]==2*k-1) && (sg[4]>sg[3]) ) {  // W#[k,2r-1]
     2275      if( (sg[5]==2*k-1) && (sg[4]>sg[3]) )
     2276      {  // W#[k,2r-1]
    21392277        r = sg[4] - sg[3]; cnt++;
    21402278        SG_Typ = SG_Typ + " W#[k,2r-1]=W["+string(k)+","+string(2*r-1)+"]";
    21412279      }
    2142       if( (sg[5]==2*k) && (sg[4]>sg[3]) ) {  // W#[k,2r]
     2280      if( (sg[5]==2*k) && (sg[4]>sg[3]) )
     2281      {  // W#[k,2r]
    21432282        r = sg[4] - sg[3]; cnt++;
    21442283        SG_Typ = SG_Typ + " W#[k,2r]=W["+string(k)+","+string(2*r)+"]";
    … …  
    21632302  r = sg[4] + k;
    21642303  s = sg[5] + r - 1;
    2165   if(k>2 && r>2 && s>2) {                               // T[k,r,s]
     2304  if(k>2 && r>2 && s>2)
     2305  {                               // T[k,r,s]
    21662306    cnt++;
    21672307    SG_Typ = SG_Typ + " T[k,r,s]=T["+string(k)+","+string(r)+","+string(s)+"]";
    … …  
    21692309
    21702310  // finde weitere Moeglicjkeiten.
    2171   if(sg[3]==2) {  // Q[...]
    2172     if(parity(sg[4])) { // 4. Stelle ist ungerade.
    2173       if(sg[4]==sg[5]) {                                // Q[6k+4]
     2311  if(sg[3]==2)
     2312  {  // Q[...]
     2313    if(parity(sg[4]))
     2314    { // 4. Stelle ist ungerade.
     2315      if(sg[4]==sg[5])
     2316      {                                // Q[6k+4]
    21742317        k=(sg[4]+1) div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+4]=Q["+string(6*k+4)+"]";
    21752318      }
    2176       if(sg[4]+1==sg[5]) {                      // Q[6k+5]
     2319      if(sg[4]+1==sg[5])
     2320      {                      // Q[6k+5]
    21772321        k=sg[5] div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+5]=Q["+string(6*k+5)+"]";
    21782322      }
    21792323    }
    2180     else { // 4. Stelle ist gerade.
    2181       if(sg[4]==sg[5]+1) {                      // Q[6k+6]
     2324    else
     2325    { // 4. Stelle ist gerade.
     2326      if(sg[4]==sg[5]+1)
     2327      {                      // Q[6k+6]
    21822328        k=sg[4] div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+6]=Q["+string(6*k+6)+"]";
    21832329      }
    2184       if(sg[4]<sg[5]) {                 // Q[k,r]
     2330      if(sg[4]<sg[5])
     2331      {                 // Q[k,r]
    21852332        k = (sg[4]+2) div 2;
    2186         if(k>=2) {
     2333        if(k>=2)
     2334        {
    21872335          r=sg[5]+1-2*k; cnt++;
    21882336          SG_Typ=SG_Typ+" Q[k,r]=Q["+string(k)+","+string(r)+"]";
    … …  
    21912339    }
    21922340  }
    2193   else {           // S[...]
    2194     if(parity(sg[3])) {  // 3. Stelle ist ungerade.
     2341  else
     2342  {           // S[...]
     2343    if(parity(sg[3]))
     2344    {  // 3. Stelle ist ungerade.
    21952345      k = (sg[3]-1) div 2;
    2196       if(sg[3]==sg[4]+3 && sg[3]==sg[5]+2) {    // S[12k-1]
     2346      if(sg[3]==sg[4]+3 && sg[3]==sg[5]+2)
     2347      {    // S[12k-1]
    21972348        cnt++; SG_Typ = SG_Typ + " S[12k-1]=S["+string(12*k-1)+"]";
    21982349      }
    2199       if(sg[3]==sg[4]+3 && sg[3]==sg[5]+1) {    // s[12k]
     2350      if(sg[3]==sg[4]+3 && sg[3]==sg[5]+1)
     2351      {    // s[12k]
    22002352        cnt++; SG_Typ = SG_Typ + " S[12k]=S["+string(12*k)+"]";
    22012353      }
    2202       if(sg[3]==sg[4]+2 && sg[5]>=sg[4]+1) {    // S[k,r]
     2354      if(sg[3]==sg[4]+2 && sg[5]>=sg[4]+1)
     2355      {    // S[k,r]
    22032356        r = sg[5] - 2*k; cnt++;
    22042357        SG_Typ = SG_Typ + " S[k,r]=S["+string(k)+","+string(r)+"]";
    22052358      }
    2206       if(sg[3]==sg[5]+2 && sg[4]>=sg[5]) {              // S#[k,2r-1]
     2359      if(sg[3]==sg[5]+2 && sg[4]>=sg[5])
     2360      {              // S#[k,2r-1]
    22072361        r = sg[4] - 2*k + 1; cnt++;
    22082362        SG_Typ = SG_Typ + " S#[k,2r-1]=S#["+string(k)+","+string(2*r-1)+"]";
    22092363      }
    2210       if(sg[3]==sg[5]+1 && sg[4]>=sg[5]) {              // S#[k,2r]
     2364      if(sg[3]==sg[5]+1 && sg[4]>=sg[5])
     2365      {              // S#[k,2r]
    22112366        r = sg[4] - 2*k + 1; cnt++;
    22122367        SG_Typ = SG_Typ + " S#[k,2r]=S#["+string(k)+","+string(2*r)+"]";
    22132368      }
    22142369    }
    2215     else { // 3. Stelle ist gerade.
    2216       if(sg[3]==sg[5]+1 && sg[5]==sg[4]+3) {    // S[12k+4]
     2370    else
     2371    { // 3. Stelle ist gerade.
     2372      if(sg[3]==sg[5]+1 && sg[5]==sg[4]+3)
     2373      {    // S[12k+4]
    22172374        k = (sg[3]-2) div 2; cnt++;
    22182375        SG_Typ = SG_Typ + " S[12k+4]=S["+string(12*k+4)+"]";
    22192376      }
    2220       if(sg[3]==sg[5]+2 && sg[5]==sg[4]+1) {    // S[12k+5]
     2377      if(sg[3]==sg[5]+2 && sg[5]==sg[4]+1)
     2378      {    // S[12k+5]
    22212379        k = (sg[3]-2) div 2; cnt++;
    22222380        SG_Typ = SG_Typ + " S[12k+5]=S["+string(12*k+5)+"]";
    … …  
    22352393  list v;
    22362394
    2237   if(sg[1]==1 && sg[2]==0 && sg[3]==1) {
     2395  if(sg[1]==1 && sg[2]==0 && sg[3]==1)
     2396  {
    22382397      v=HKclass7_teil_1(sg, SG_Typ, cnt);
    22392398  }
    2240   else {
     2399  else
     2400  {
    22412401      v[1]="not in list";
    22422402      v[2]=0;
    … …  
    22532413
    22542414  debug_log(2, "entering HKclass7_teil_1", sg);
    2255   if(sg[4] == 2) {                                      // V[...]
    2256     if(sg[5] == 0 && sg[6] == 1 && sg[7]>0) {   // V[1,r]
     2415  if(sg[4] == 2)
     2416  {                                      // V[...]
     2417    if(sg[5] == 0 && sg[6] == 1 && sg[7]>0)
     2418    {   // V[1,r]
    22572419      r = sg[7] - 1; cnt++; SG_Typ = SG_Typ + " V[1,r]=V[1,"+string(r)+"]";
    22582420    }
    2259     if(sg[5] == 1 && sg[7] == 1) {                      // V#[1,2r-1]
     2421    if(sg[5] == 1 && sg[7] == 1)
     2422    {                      // V#[1,2r-1]
    22602423      r=sg[6]+1; cnt++; SG_Typ=SG_Typ+" V#[1,2r-1]=V#[1,"+string(2*r-1)+"]";
    22612424    }
    2262     if(sg[5] == 1 && sg[7] == 2) {                      // V#[1,2r]
     2425    if(sg[5] == 1 && sg[7] == 2)
     2426    {                      // V#[1,2r]
    22632427      r=sg[6]+1; cnt++; SG_Typ=SG_Typ+" V#[1,2r]=V#[1,"+string(2*r)+"]";
    22642428    }
    … …  
    22662430  //            Moegliche U[...]'s
    22672431  k = sg[4];
    2268   if(sg[5]==2*k-1 && sg[6]==0 && sg[7]==sg[5]) {        // U[12k]
     2432  if(sg[5]==2*k-1 && sg[6]==0 && sg[7]==sg[5])
     2433  {        // U[12k]
    22692434    cnt++;SG_Typ = SG_Typ + " U[12k]=U["+string(12*k)+"]";
    22702435  }
    2271   if(sg[5]==2*k && sg[6]==0 && sg[7]==sg[5]) {  // U[12k+4]
     2436  if(sg[5]==2*k && sg[6]==0 && sg[7]==sg[5])
     2437  {  // U[12k+4]
    22722438    cnt++;SG_Typ = SG_Typ + " U[12k+4]=U["+string(12*k+4)+"]";
    22732439  }
    2274   if(sg[5]==2*k-1 && sg[6]>0 && sg[7]==sg[5]) { // U[k,2r-1]
     2440  if(sg[5]==2*k-1 && sg[6]>0 && sg[7]==sg[5])
     2441  { // U[k,2r-1]
    22752442    r=sg[6]-1; cnt++;
    22762443    SG_Typ=SG_Typ+" U[k,2r-1]=U["+string(k)+","+string(2*r-1)+"]";
    22772444  }
    2278   if(sg[5]==2*k-1 && sg[6]>0 && sg[7]==2*k) {   // U[k,2r]
     2445  if(sg[5]==2*k-1 && sg[6]>0 && sg[7]==2*k)
     2446  {   // U[k,2r]
    22792447    r = sg[6]; cnt++;
    22802448    SG_Typ = SG_Typ + " U[k,2r]=U["+string(k)+","+string(2*r)+"]";
    … …  
    23122480  if(len>=3) { s = #[3]; }
    23132481  else { s = 0; }
    2314   if( k<0 || r<0 || s<0) {
     2482  if( k<0 || r<0 || s<0)
     2483  {
    23152484    "Initial condition failed: k>=0; r>=0; s>=0";
    23162485    "k="+string(k)+" r="+string(r)+"   s="+string(s);
    … …  
    23752544  Tp = read(dbmLink, typ);
    23762545  debug_log(2,"DBMread(", typ, ")=", Tp, ".");
    2377   if( Tp != "(null)" && Tp !="" ) {
     2546  if( Tp != "(null)" && Tp !="" )
     2547  {
    23782548    string Key = "I_", typ;
    23792549    S = "f = ", Tp, ";";
    … …  
    23852555    v = f, crk, Mu, MlnCd;
    23862556  }
    2387   else {
     2557  else
     2558  {
    23882559    v = 0, 0, 0, 0;
    23892560  }
    … …  
    24282599
    24292600  r=1;
    2430   for(i=n; i>0; i--,r++) {
     2601  for(i=n; i>0; i--,r++)
     2602  {
    24312603//  for(i=1; i<=n; i=i+1)
    24322604    B[rvar(x(r))] = x(i);
    24332605    if(i>2 && random(1,10)<3) { B[rvar(x(r))] = B[rvar(x(r))] + x(i-1); }
    24342606//    if(i==1 && random(1,10)<4) { B[rvar(x(r))] = B[rvar(x(r))]- x(n); }
    2435     if(i>0) {
    2436       for(b=3; b<5; b=b+1) {
     2607    if(i>0)
     2608    {
     2609      for(b=3; b<5; b=b+1)
     2610      {
    24372611        // B[rvar(x(r))] = B[rvar(x(r))] + random(0,9) * x(i)^(b+2);
    2438         if(random(1,20)<3) {
     2612        if(random(1,20)<3)
     2613        {
    24392614          B[rvar(x(r))] = B[rvar(x(r))] - random(-2,2)*x(b)^2;
    24402615        }
    … …  
    24612636   int len = size(#);
    24622637//   int printresult = printlevel - level +1;
    2463 //   if(level>1) {
     2638//   if(level>1)
     2639//   {
    24642640//     dbprint(printresult, "Debug:("+ string(level)+ "): ", #[2..len]);
    24652641//   }
    24662642//   else { dbprint(printresult, #[1..len]); }
    24672643   if( defined(@DeBug) == 0 ) { init_debug(); }
    2468    if(@DeBug>=level) {
     2644   if(@DeBug>=level)
     2645   {
    24692646      if(level>1) { "Debug:("+ string(level)+ "): ", #[1..len]; }
    24702647      else { #[1..len]; }
    … …  
    24902667  if( defined(@DeBug) != 0 ) { newDebug = @DeBug; }
    24912668
    2492   if( size(#) > 0 ) {
     2669  if( size(#) > 0 )
     2670  {
    24932671    newDebug=#[1];
    24942672  }
    2495   else {
     2673  else
     2674  {
    24962675    string s=system("getenv", "SG_DEBUG");
    2497     if( s != "" && defined(@DeBug)==0) {
     2676    if( s != "" && defined(@DeBug)==0)
     2677    {
    24982678      s="newDebug="+s;
    24992679      execute(s);
    25002680    }
    25012681  }
    2502   if( defined(@DeBug) == 0) {
     2682  if( defined(@DeBug) == 0)
     2683  {
    25032684    int @DeBug = newDebug;
    25042685    export @DeBug;
    25052686    if(@DeBug>0) { "Debugging level is set to ", @DeBug; }
    25062687  }
    2507   else {
     2688  else
     2689  {
    25082690    if( (size(#) == 0) && (newDebug < @DeBug) ) { return(); }
    2509     if( @DeBug != newDebug) {
     2691    if( @DeBug != newDebug)
     2692    {
    25102693      int oldDebug = @DeBug;
    25112694      @DeBug = newDebug;
    25122695      if(@DeBug>0) { "Debugging level change from ", oldDebug, " to ",@DeBug; }
    2513       else {
     2696      else
     2697      {
    25142698        if( @DeBug==0 && oldDebug>0 ) { "Debugging switched off."; }
    25152699      }
    … …  
    25892773  Jfsyz = fk, diff(fk, x(1));
    25902774  Mat   = matrix(syz(Jfsyz));
    2591   if( (fk-subst(fk,x(1),0)) != 0  &&  (fk-subst(fk,x(2),0)) != 0 ) {
     2775  if( (fk-subst(fk,x(1),0)) != 0  &&  (fk-subst(fk,x(2),0)) != 0 )
     2776  {
    25922777    // Wenn k>0 ist die Wahl fuer x & y bereits getroffen
    25932778    // sonst bestimmen x und y
    … …  
    26062791
    26072792//------------------- permutation of x and y, if needed -----------------------
    2608   if( k==1 ) {
     2793  if( k==1 )
     2794  {
    26092795    debug_log(2, "Fak-7:",Show(f)," jet=",Show(fk));
    2610     if(Coeff(jet(f, pt), x(1), x(1)^pt) == 0) {
     2796    if(Coeff(jet(f, pt), x(1), x(1)^pt) == 0)
     2797    {
    26112798      VERT = basering,x(2),x(1);
    26122799      f    = VERT(f);
    … …  
    26432830  intvec Haeufigkeit = RFlg;
    26442831
    2645   for( j=1; j<=n ; j=j+1) {
     2832  for( j=1; j<=n ; j=j+1)
     2833  {
    26462834    Koef = coef(fi, x(j));
    26472835    Haeufigkeit[j] = ncols(Koef);
    26482836    if(Coeff(fi, x(j),0) == 0) { Haeufigkeit[j] = Haeufigkeit[j] + 1;}
    26492837  }
    2650   for( j=n; j>0 ; j=j-1) {
     2838  for( j=n; j>0 ; j=j-1)
     2839  {
    26512840    l1  = 0;
    26522841    l1w = 0;
    … …  
    26762865{
    26772866  int CH = char(basering);
    2678   if(CH >= 2 && CH<=13) {
     2867  if(CH >= 2 && CH<=13)
     2868  {
    26792869    "Ring has characteristic ",CH;
    26802870    "Characteristic other than 0 or 0<char<13 is not yet implemented";
    … …  
    27102900  debug_log(6, "Suche Type:", Typ);
    27112901  //---------------------- decode between brackets ----------------------------
    2712   if( find(s1, ",") == 0) {
     2902  if( find(s1, ",") == 0)
     2903  {
    27132904    debug_log(8, "  Number of columns: 0");
    27142905    s2 = "k = "+s1+";";
    … …  
    27202911    if( Typ == "Z[") { t = 6; }
    27212912    if( Typ == "U[") { t = 12; }
    2722     if( t > 1 ) {
     2913    if( t > 1 )
     2914    {
    27232915      i = k;
    27242916      k = k div t;
    27252917      b = i - t*k;
    27262918      if( (s1 == "Q[") && (b==0) ) { k=k-1; b=6; }
    2727       if(Typ == "Z[") {
     2919      if(Typ == "Z[")
     2920      {
    27282921        if(b==0) { k=k-1; b=6; }
    27292922        if(b==1) { k=k-1; b=7; }
    … …  
    27322925      else { s3 = string(t)+"k+"+string(b); }
    27332926    }
    2734     if( Typ == "S[") {
     2927    if( Typ == "S[")
     2928    {
    27352929      i = k+1;
    27362930      k = i/12;
    27372931      b = i - 12*k;
    27382932      if( b == 1 ) { s3 = "k"; }
    2739       else {
     2933      else
     2934      {
    27402935        if(b==0) { s3 = "12k"+string(b-1); }
    27412936        else { s3 = "12k+"+string(b-1); }
    … …  
    27452940  }  // es kommt mindestens ein komma vor...
    27462941  //----------------------- more than 1 parameter -----------------------------
    2747   else {
     2942  else
     2943  {
    27482944    b  = find(s1, ",");
    27492945    s2 = "k = ",s1[1..b-1],";";
    27502946    execute(s2);
    27512947    s1 = s1[b+1..size(s1)];
    2752     if(find(s1, ",") == 0) {
     2948    if(find(s1, ",") == 0)
     2949    {
    27532950      debug_log(8, "  Number of columns 1");
    27542951      s2 = "r = "+s1+";";
    … …  
    27582955      if(r==0) { s4 = string(0); }
    27592956      if(k==0 && Typ=="Z[") { s3 = string(1); }
    2760       if(Typ[2] == "#") {
     2957      if(Typ[2] == "#")
     2958      {
    27612959        i = r+1;
    27622960        r = i div 2;
    … …  
    27682966    }  // es kommt mindestens zwei komma vor...
    27692967    //----------------------- get third parameter -----------------------------
    2770     else {
     2968    else
     2969    {
    27712970      debug_log(8, "  Number of columns >=2");
    27722971      debug_log(2, "Y[k,r,s] / Z[k,r,s] / T[k,r,s]");
    27732972      b  = find(s1, ",");
    27742973      s2 = "r = ",s1[1..b-1],";";
    2775       execute(s2);
     2974      if ((s2[5]>"0") && (s2[5]<="9")) { execute(s2); }
    27762975      s2 = "s = ",s1[b+1..size(s1)],";";
    2777       execute(s2);
     2976      if ((s2[5]>"0") && (s2[5]<="9")) { execute(s2); }
    27782977      if(Typ=="Y[") { s2 = "Y[k,r,s]"; }
    27792978      if(Typ=="Z[") { s2 = "Z[k,r,s]"; }
    … …  
    28023001  init_debug();
    28033002
    2804   if( typeof(#[1]) == "string" ) {
     3003  if( typeof(#[1]) == "string" )
     3004  {
    28053005    if(checkring()) { return(#[1]); }
    28063006    return(normalform(#[1]));
    28073007  }
    2808   if( typeof(#[1]) == "poly" ) {
     3008  if( typeof(#[1]) == "poly" )
     3009  {
    28093010    if(checkring()) { return(#[1]); }
    28103011    return(quickclass(#[1]));
    … …  
    28363037
    28373038  if(checkring()) { return(s_in); }
    2838   if(nvars(basering)<=1) {
     3039  if(nvars(basering)<=1)
     3040  {
    28393041    "We need at least 2 variables in basering, you have",nvars(basering),".";
    28403042    return();
Note: See TracChangeset for help on using the changeset viewer.