source: git/Singular/LIB/polyclass.lib @ 06808a

//////////////////////////////////////////////////////////////////////////////
version="version polyclass.lib 4.1.1.0 Dec_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.

Acknowledgements: This research was supported by 
the Staff Exchange Bursary Programme of the University of Pretoria, DFG SPP 1489, 
DFG TRR 195. The financial assistance of the National Research Foundation (NRF),
South Africa, towards this research is hereby acknowledged. Opinions expressed 
and conclusions arrived at are those of the author and are not necessarily to be 
attributed to the National Research Foundation, South Africa.


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);}