Changeset d2c1f8 in git


Ignore:
Timestamp:
Feb 1, 2022, 3:15:47 PM (2 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
305f3718988da09be4b95025aed6bc281e4b5e9e
Parents:
a6ae59204fea5adeb820cb3048d2cb60915467d7
Message:
integralbasis.lib: less noise, removed debug stuff
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/integralbasis.lib

    ra6ae592 rd2c1f8  
    22///////////////////////////////////////////////////////////////////////////////
    33///////////////////////////////////////////////////////////////////////////////
    4 version="version integralbasis.lib 4.2.1.3 Dec_2021 "; // $Id$
     4version="version integralbasis.lib 4.3.0.1 Feb_2022 "; // $Id$
    55category="Commutative Algebra";
    66info="
     
    280280
    281281
    282   // We chech if the only singularity is at the origin.
     282  // We check if the only singularity is at the origin.
    283283  //check0 = 0;
    284284  if(check0 == 1)
    285285  {
    286     "Check at origin";
     286    dbprint(dbg,"Check at origin");
    287287    int c0 = checkAt0(f, modular);
    288288
     
    515515  ideal J = f, diff(f, var(1)), diff(f, var(2));
    516516
    517   if(dbg >= 4){
     517  if(dbg >= 4)
     518  {
    518519    "The original singular locus is";
    519520    J;
     
    523524  {
    524525    list out = trivialBasis(f);
    525     "out";
    526     out;
    527526    return(list(out[1], out[2], 0, 0));
    528527  }
     
    753752  ideal elimJ = elim(jac, v);
    754753  poly dJ = elimJ[1];
    755   option("redSB");
     754  option(redSB);
    756755
    757756  ideal PP = changeDenominatorFast(U, den, dJ, f);
     
    793792{
    794793  int dbg = printlevel - voice + 4;
    795   option("redSB");
     794  option(redSB);
    796795  f = reduce(f, std(D));
    797796
     
    23022301  if(deg(f2, (1,0,0)) > 0)
    23032302  {
    2304     "f2", f2;
    2305     "Polynomial is not over the ground field";
    2306     ~;
     2303    //"f2", f2;
     2304    ERROR("Polynomial is not over the ground field");
    23072305    gfCheck = 0;
    23082306  }
     
    26542652  ch[pos] = ch[pos] + 1;
    26552653
    2656 //  "md: ", md;
    2657 //  "ch: ", ch;
    2658 //  "cl: ", cl;
    26592654  while(ch[pos] > md[pos])
    26602655  {
     
    26632658    ch[pos] = ch[pos] + 1;
    26642659  }
    2665 //  "output: ", ch;
    26662660  return(ch);
    26672661}
     
    29552949    int den = PE[1][2];
    29562950
    2957     //"here";
    2958     //"h, g", h, g;
    2959 
    2960     //"b debug overflow <-";
    2961 
    29622951    if(size(h) > 1)
    29632952    {
    29642953      h = subst(h, var(1), var(1)^den);
    29652954      poly hs = subst(h, var(2), g);
    2966       //"b debug overflow <-";
    29672955
    29682956      matrix MM;
     
    29762964      int oo = deg(MM[1, ncols(MM)])*deg(h, intvec(0,1)) + deg(h, intvec(1,0))*den;
    29772965    }
    2978     //~;
    29792966
    29802967    number oro = oo/number(den);
    29812968
    2982     //"h, oro", h, oro;
    29832969    kill h;
    29842970    kill g;
     
    30193005                    // the ground field.
    30203006  list gfCheckList;
    3021 
    3022   //"nClasses: ", nClasses;
    3023   //"size(I2Lifted): ", size(I2Lifted);
    3024   //"I2Lifted: ", I2Lifted;
    3025   //"degExpand: ", degExpand;
    30263007
    30273008  int wrongNumber = 0; // If some hensel block contains different classes
     
    30923073            } else
    30933074            {
    3094               "RING EXPECTED! Please contact the developers.";
    3095               ~;
     3075              ERROR("RING EXPECTED! Please contact the developers.");
    30963076            }
    30973077          }
     
    31033083            // The polynomial computed is not over the ground field.
    31043084            // The classes computed are wrong, we need to recompute.
    3105             "Polynomial not over the ground field.";
     3085            ERROR("Polynomial not over the ground field.");
    31063086            gfCheck = 0;
    31073087          }
     
    32193199          {
    32203200            k = chVec[i];
    3221             //"i, k", i, k;
    32223201            if(k > 0)
    32233202            {
     
    33763355  if(i == 1)
    33773356  {
    3378     //"Trivial case";
    33793357    return(ib[1][1]);
    33803358  }
     
    34003378  if(mExp > ib[i][2])
    34013379  {
    3402     "WRONG EXPONENT. CHECK!!";
     3380    ERROR("WRONG EXPONENT. CHECK!!");
    34033381    ~;
    34043382    setring BR;
     
    34273405  if(deg(red, va) > 0)
    34283406  {
    3429     "Wrong degree! Check!";
    3430     ~;
     3407    ERROR("Wrong degree! Check!");
    34313408  }
    34323409  setring BR;
     
    34723449      } else
    34733450      {
    3474         "Not implemented.";
     3451        ERROR("Not implemented.");
    34753452        return(list());
    34763453      }
     
    39113888    } else
    39123889    {
    3913     "ERROR";
    3914     ~;
    39153890      ERROR("f(y)*g(y) != h(0,y)");
    39163891    }
     
    39313906    } else
    39323907    {
    3933       "ERROR";
    3934       ~;
    39353908      ERROR("f(y)*g(y) != h(0,y)");
    39363909    }
     
    41174090    if(fLoc == 1)
    41184091    {
    4119       "Warning! No local component. This may indicate you are computing the basis at a value of X where there is no singularity.";
     4092      dbprint(dbg,"Warning! No local component. This may indicate you are computing the basis at a value of X where there is no singularity.");
    41204093    }
    41214094    comps[1] = fGlob[2];    // comp[1] is the component outside the origin.
     
    44354408    {
    44364409      // Singularities at infinity
    4437       "Singularities at infinity";
     4410      dbprint(dbg,"Singularities at infinity");
    44384411      return(0);
    44394412    }
    44404413  } else
    44414414  {
    4442     "Check at origin: FALSE";
     4415    dbprint(dbg,"Check at origin: FALSE");
    44434416    return(0);
    44444417  }
     
    46714644  if(dbg >= 1)
    46724645  {
    4673     "Hensel lifting - order = ", maxExpDen;
     4646    dbprint(dbg,"Hensel lifting - order = ", maxExpDen);
    46744647  }
    46754648  // We compute the lifiting of the factor outside the origin up to the
     
    48694842                                    { algname="@o";}
    48704843         else {
    4871            "** Sorry -- could not find a free name for the primitive element.";
    4872            "** Try e.g. a ring without '@a' or '@b' as variable.";
    4873            return();
     4844           ERROR("** Sorry -- could not find a free name for the primitive element.";
     4845           "** Try e.g. a ring without '@a' or '@b' as variable.");
    48744846         }}
    48754847       }
     
    49054877  //------------- Fall 2: Bisheriger Ring hatte ein Minimalpolynom: -----------
    49064878  algname=parstr(altring);           // Name des algebraischen Elements
    4907   if (npars(altring)>1) {"only one Parameter is allowed!!"; return(altring);}
     4879  if (npars(altring)>1) {ERROR("only one Parameter is allowed!");}
    49084880
    49094881  //---------------- Minimalpolynom in ein Polynom umwandeln: -----------------
Note: See TracChangeset for help on using the changeset viewer.