source: git/Singular/LIB/polyclass.lib @ a66494

//////////////////////////////////////////////////////////////////////////////
version="version polyclass.lib 4.1.0.3 Nov_2017 "; // $Id$
category="Commutative Algebra";
info="
LIBRARY: polyclass.lib   Data types for normal form equations 
AUTHORS:               Janko Boehm,      email: boehm@mathematik.uni-kl.de
                       Magdaleen Marais, email: magdaleen.marais@up.ac.za
                       Gerhard Pfister,  email: pfister@mathematik.uni-kl.de


OVERVIEW:
This library implements a ring independent polynomial type used for the return value in
classify2.lib and realclassify.lib. You can use +,  * and == for addition, multiplication 
and comparison. The key over contains the base ring of the polynomial, the key value its 
value as a polynomial of type poly. The constructor can be called by assigning a polynomial 
of type poly to a polynomial of type Poly via =.

Moreover the library implements a class NormalformEquation consisting out of a string type, 
an integer milnorNumber, a Poly normalFormEquation, and integer modality, a list of numbers 
parameters, a list variables, an integer corank, in the real case, an integer inertiaIndex, 
a list of open intervals represented as lists consisting out of two rationals used to select 
a real root of the minimal polynomial (which is stored in the variable minpoly of the polynomial 
ring containing normalFormEquation, that is, in normalFormEquation.in), or if no minimal 
polynomial is defined then an interval containing the rational parameter value.

KEYWORDS:
polynomials

SEE ALSO: realclassify_lib, classify2_lib

PROCEDURES:
makePoly(f);  constructor for ring independent polynomial type Poly
printPoly(f); print routine for polynomial type Poly
printNormalFormEquation(F); print routine for normal form equations
";

LIB "sing.lib";

static proc mod_init()
{
  newstruct("Poly","ring in,poly value");
  newstruct("NormalFormEquation","list vars, string singularityType, int milnorNumber, Poly normalFormEquation, int modality, list parameters, int corank, int inertiaIndex, int determinacy, int realCase");
  system("install","Poly","print",printPoly,1);
  system("install","Poly","string",stringPoly,1);
  system("install","Poly","+",addPoly,2);
  system("install","Poly","*",multPoly,2);
  system("install","Poly","^",expPoly,2);
  system("install","Poly","==",equalPoly,2);
  system("install","Poly","=",makePoly,1);
  system("install","NormalFormEquation","print",printNormalFormEquation,1);
}

proc printNormalFormEquation(NormalFormEquation F)
"USAGE: printNormalFormEquation(F); F NormalFormEquation
RETURN: print a normal form equation
EXAMPLE: example printNormalFormEquation, shows an example"
{
def R=basering;
Poly f=F.normalFormEquation;
def SS=f.in;
setring SS;
"Corank = "+string(F.corank);
if (F.realCase){"Inertia index = "+string(F.inertiaIndex);}
"Normalform equation of type = "+(F.singularityType);
"Normalform equation = "+string(f.value);
"Milnor number = "+string(F.milnorNumber);
"Modality = "+string(F.modality);
if (F.modality>=1){
  if (F.modality==1){
      "Parameter term = "+string(F.parameters[1][1]);
  } else {
      string paraterms="Parameter terms = ";
      for (int i =1;i<=size(F.parameters);i++){
          paraterms=paraterms+string(F.parameters[i][1]);
          if (i<size(F.parameters)){paraterms = paraterms +", ";}
      }
      paraterms;
  }
  if (minpoly!=0){"Minimal polynomial = "+string(minpoly);}
  if (F.realCase && minpoly!=0){
      if (F.modality>1){ERROR("Not implemented");}
      "Interval = ["+string(F.parameters[1][2][1])+", "+string(F.parameters[1][2][2])+"]";
  }
}
"Determinacy <= "+string(F.determinacy);
setring R;
}
example
{
 "EXAMPLE:"; echo=2;
 ring R=(0,a),(x,y,z,w),ds;
 minpoly = a^2-2;
 Poly f=x^4+x^2*y^2+a*y^8+z^2-w^2;
 NormalFormEquation F;
 F.vars = ringlist(R)[2];
 F.realCase = 1;
 F.normalFormEquation = f;
 F.modality = 1;
 F.corank = 2;
 F.inertiaIndex = 1;
 F.determinacy = 8;
 F.milnorNumber = milnor(f.value);
 F.parameters = list(list(a*y^8,list(0,2)));
 F.singularityType = "X[13]";
 F;
 ring R=(0),(x,y,z,w),ds;
 Poly f=x^4+x^2*y^2+7*y^8+z^2-w^2;
 NormalFormEquation F;
 F.vars = ringlist(R)[2];
 F.realCase = 1;
 F.normalFormEquation = f;
 F.modality = 1;
 F.corank = 2;
 F.inertiaIndex = 1;
 F.determinacy = 8;
 F.milnorNumber = milnor(f.value);
 F.parameters = list(list(7*y^8,list(-6,8)));
 F.singularityType = "X[13]";
 F;

}



proc makePoly(poly f)
"USAGE: makePoly(f); f poly
RETURN: make a ring independent Poly from a poly in the basering
EXAMPLE: example makePoly, shows an example"
{
Poly F;
F.in=basering;
F.value=f;
return(F);
}
example
{
 "EXAMPLE:"; echo=2;
 ring R=0,(x,y),dp;
 Poly f=3*x^2+x*y+1;
 Poly g=2*x+y^3;
 f*g;
 f+g;
 f^3;
}


static proc printPoly(Poly f)
"USAGE: printPoly(f); f Poly
RETURN: print Poly
EXAMPLE: example printPoly, shows an example"
{
def R=basering;
def SS=f.in;
setring SS;
f.value;
setring R;
}
example
{
 "EXAMPLE:"; echo=2;
 ring R=0,(x,y),dp;
 Poly f=3*x^2+x*y+1;
 f;
}

static proc stringPoly(Poly f)
{
def R=basering;
def SS=f.in;
setring SS;
string st = string(f.value);
setring R;
return(st);}


static proc addPoly(Poly f,Poly g)
{
def R=basering;
def S1=f.in;
setring S1;
Poly fplusg=f.value+g.value;
setring R;
return(fplusg);}

static proc multPoly(Poly f,Poly g)
{
def R=basering;
def S1=f.in;
setring S1;
Poly ftimesg=(f.value)*(g.value);
setring R;
return(ftimesg);}


static proc equalPoly(Poly f,Poly g)
{
def R=basering;
def S1=f.in;
setring S1;
int fgequal=(f.value)==(g.value);
setring R;
return(fequal);}


static proc expPoly(Poly f,int n)
{
def R=basering;
def S1=f.in;
setring S1;
Poly fexpn=(f.value)^n;
setring R;
return(fexpn);}