Changeset 03645f4 in git


Ignore:
Timestamp:
Sep 26, 1997, 10:14:35 AM (26 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', 'a719bcf0b8dbc648b128303a49777a094b57592c')
Children:
f0596e3b7b21bb03a5e31efdb572b2f9e62183e1
Parents:
99712fe05cf5af352d82d7cd058e186881446a54
Message:
Erster Teil vor Aenderung von GMG
Modified Files:
	classify.lib hilbert.lib
Added Files:
 	tools.lib


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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/classify.lib

    r99712f r03645f4  
    1 // $Id: classify.lib,v 1.12 1997-08-15 07:46:44 krueger Exp $
    2 //=============================================================================
     1// $Id: classify.lib,v 1.13 1997-09-26 08:14:35 krueger Exp $
    32//
    4 // Please send bugs and comments to krueger@mathematik.uni-kl.de
     3//  A library for the classification of isolated hypersurface singularities
     4//  with respect to right equivalence. Based on the determinator of
     5//  singularities by V.I. Arnold.
     6//  Author: Kai Krueger, (ev. Post Adresse)
     7//  Please send bugs and comments to krueger@mathematik.uni-kl.de
     8//  last modified:
    59//
    6 //=============================================================================
    7 
    8 LIBRARY:  classify.lib
    9 
    10  classify(f);            compute the Class of f.
    11 
    12 LIBRARY:  Kclass.lib
    13   Klassifiziere(poly f);             determine the typ of the singularity f
    14   Funktion1bis(poly f, int corank);  (for internal use only)
    15   Funktion3(poly f, int corank);     (for internal use only)
    16   Funktion6(poly f, int corank);     (for internal use only)
    17   Funktion13(poly f, int corank);    (for internal use only)
    18   Funktion17(poly f, int corank);    (for internal use only)
    19   Funktion25(poly f, int corank);    (for internal use only)
    20   Funktion40(poly f, int corank);    (for internal use only)
    21   Funktion50(poly f, int corank);    (for internal use only)
    22   Funktion51(poly f, int corank);    (for internal use only)
    23   Funktion52(poly f, int corank);    (for internal use only)
    24   Funktion54(poly f, int corank);    (for internal use only)
    25   Funktion56(poly f, int corank);    (for internal use only)
    26   Funktion58(poly f, int corank);    (for internal use only)
    27   Funktion59(poly f, int corank);    (for internal use only)
    28   Funktion66(poly f, int corank);    (for internal use only)
    29   Funktion82(poly f, int corank);    (for internal use only)
    30   Funktion83(poly f, int corank);    (for internal use only)
    31   Funktion97(poly f, int corank);    (for internal use only)
    32   Funktion103(poly f, int corank);   (for internal use only)
    33   Funktion104(poly f, int corank);   (for internal use only)
    34   Funktion105(poly f, int corank);   (for internal use only)
    35   FunktionNoClass(poly f, int corank);  (for internal use only)
    36   Isomorphie_s82_x(poly f, poly fk, int k); (for internal use only)
    37   Isomorphie_s82_z(poly f, poly fk, int k); (for internal use only)
    38   Tschirnhaus(poly f, int corank);   (for internal use only)
    39   Isomorphie_s17 (poly f, poly fk, int k, int ct);
     10///////////////////////////////////////////////////////////////////////////////
     11
     12LIBRARY:  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES 
     13
     14classify(f);         normal form of poly f determined with Arnold's method
     15quickclass(f)        normal form of f determined by invariants (milnorcode)
     16corank(f);           computes the corank of f (i.e. of the Hessian of f)
     17basicinvariants(f);  computes Milnor number, determinacy-bound and corank of f
     18milnorcode(f[,e]);   Hilbert poly of [e-th] Milnor algebra coded with Hcode
     19Hcode(v);            coding of intvec v acoording to the number repetitions
     20morsesplit(f);       residual part of f after applying the splitting lemma
     21tschirnhaus(f,v);    Tschirnhaus transformation of f w.r.t. variable v
     22singinfo(N,[k,]);    info about singularity given by its name N and index k
     23singularity(s,[]);   normal form of singularity given by its name s and index 
     24init_debug([n]);     print trace and debugging information depending on int n 
     25internalfunctions(); display names of internal procedures of this library
     26(parameters in square brackets [] are optional)
     27
     28LIB "inout.lib";
    4029
    4130// required libraries
     
    4635LIB "hilbert.lib";
    4736
    48 //=============================================================================
     37///////////////////////////////////////////////////////////////////////////////
     38//--------------------------- output ------------------------------------------
     39///////////////////////////////////////////////////////////////////////////////
    4940//=============================================================================
    5041// TopLevel Funktion of the Arnold-Classifier.
    5142//
    52 proc classify (poly @f_in)
     43proc classify (poly f_in)
    5344USAGE:    classify(f);  f=poly
    5445COMPUTE:  Normalform and singularity type of f
     
    5950          "Kai Krueger" <krueger@mathematik.uni-kl.de>
    6051NOTE:     The procedure init_debug(n); is usefull as trace-mode.
    61           n may range from 0 to 10, higher values of n give more information.
     52          n may range from 0 to 10, higher values of n give more information.
    6253{
    6354//         or set the shell-variable SG_DEBUG to the debugging level.
     
    7364  export CharOfRing;
    7465
    75   if(checkring()) { return(@f_in); }
     66  if(checkring()) { return(f_in); }
    7667  int @show_nf = 1;    // return normal form if set to '1'
    7768
     
    10495  string @s2;
    10596  string @s4;
    106   @s1,@s2=Klassifiziere(@Conv(@f_in));
     97  @s1,@s2=Klassifiziere(@Conv(f_in));
    10798  // @s1: f nach saemtlichen Koordinatentransformationen
    10899  // @s2: Typ des Polynoms f z.b: E[18]
     
    115106    if(@s1=="1" || @s2[1,4]=="The " || @s2=="Fehler!" ) {
    116107      setring ring_top;
    117       return(@f_in);
     108      return(f_in);
    118109    }
    119110    setring Rtop;
     
    155146//=============================================================================
    156147// Id: Kclass.lib,v 1.12 1997/08/13 17:21:05 krueger Exp
    157 /=============================================================================
    158 //
    159 // Please send bugs and comments to krueger@mathematik.uni-kl.de
    160 //
    161 //=============================================================================
    162 
    163 //=========================================================================
    164 proc Kclass_lib
    165 {
    166 "
    167   Klassifiziere(poly f);             determine the typ of the singularity f
    168   Funktion1bis(poly f, int corank);  (for internal use only)
    169   Funktion3(poly f, int corank);     (for internal use only)
    170   Funktion6(poly f, int corank);     (for internal use only)
    171   Funktion13(poly f, int corank);    (for internal use only)
    172   Funktion17(poly f, int corank);    (for internal use only)
    173   Funktion25(poly f, int corank);    (for internal use only)
    174   Funktion40(poly f, int corank);    (for internal use only)
    175   Funktion50(poly f, int corank);    (for internal use only)
    176   Funktion51(poly f, int corank);    (for internal use only)
    177   Funktion52(poly f, int corank);    (for internal use only)
    178   Funktion54(poly f, int corank);    (for internal use only)
    179   Funktion56(poly f, int corank);    (for internal use only)
    180   Funktion58(poly f, int corank);    (for internal use only)
    181   Funktion59(poly f, int corank);    (for internal use only)
    182   Funktion66(poly f, int corank);    (for internal use only)
    183   Funktion82(poly f, int corank);    (for internal use only)
    184   Funktion83(poly f, int corank);    (for internal use only)
    185   Funktion97(poly f, int corank);    (for internal use only)
    186   Funktion103(poly f, int corank);   (for internal use only)
    187   Funktion104(poly f, int corank);   (for internal use only)
    188   Funktion105(poly f, int corank);   (for internal use only)
    189   FunktionNoClass(poly f, int corank);  (for internal use only)
    190   Isomorphie_s82_x(poly f, poly fk, int k); (for internal use only)
    191   Isomorphie_s82_z(poly f, poly fk, int k); (for internal use only)
    192   Tschirnhaus(poly f, int corank);   (for internal use only)
    193 ";
    194 }
    195 
    196148//=============================================================================
    197149proc Klassifiziere (poly @f)
     
    203155// Wenn nicht geht's einfach nicht. Hans fragen!
    204156  init(1);
    205   int  @n = nvars(basering);    // Zahl der Variablen des aktuellen Rings.
     157  int  @n = nvars(basering);    // Zahl der Variablen des aktuellen Rings.
    206158
    207159  // Define always 'RingDisplay' to be able to run 'Show(f)'
     
    218170  //
    219171  @s1 = "ring RingB="+string(CharOfRing)+",("+A_Z("x", @n)+"),ds;";
    220   execute @s1;                  // in diesem Ring werden Polynome angezeigt.
     172  execute @s1;                  // in diesem Ring werden Polynome angezeigt.
    221173  @s1 = "map ShowPoly=Rtop,"+A_Z("x", @n)+";";
    222   execute @s1;                  // Hiermit werden Polynome angezeigt.
     174  execute @s1;                  // Hiermit werden Polynome angezeigt.
    223175  export ShowPoly;
    224   setring Rtop;                 // in den Ausgangs-ring zurueck.
     176  setring Rtop;                 // in den Ausgangs-ring zurueck.
    225177  export RingB;
    226178
     
    274226  return(Funktion105(@f, CoRang));
    275227}
    276 //=============================================================================
     228///////////////////////////////////////////////////////////////////////////////
    277229proc Funktion1bis (poly @f, int corank)
    278230USAGE:    Funktion1bis();
     
    325277  return("","Fehler!");
    326278}
    327 //=============================================================================
     279///////////////////////////////////////////////////////////////////////////////
    328280proc Funktion3 (poly @f, int corank);
    329281USAGE:    Funktion3();
     
    344296    if( mult(@Jf) == 2) { return(Funktion6(@f, corank)); } // E[k], J
    345297    "dimension 1 und deg != 1, 2 => error, this should never occur";
    346     return("", "Fehler!");      // Should never occur
    347   }
    348   return("", "Fehler!");        // Should never occur
    349 }
    350 //=============================================================================
     298    return("", "Fehler!");      // Should never occur
     299  }
     300  return("", "Fehler!");        // Should never occur
     301}
     302///////////////////////////////////////////////////////////////////////////////
    351303//proc Funktion6 - put here
    352304proc Funktion6 (poly @f, int corank)
    353305USAGE:    Funktion6()
    354306{
    355   int @n = nvars(basering);     // Zahl der Ringvariablen
    356   poly @f3 = jet(@f, 3);        // 3-Jet von f
    357   poly @fk;                     // k-Jet von f mit Gewichten
    358   ideal @JetId;                 // Ideal fuer Gewichteten Jet
    359   ideal @Jf;                    // jacob(@fk)
    360   int  @Dim;                    // dim(@Jf)
    361   int  @Mult;                   // mult(@Jf)
    362   int @k = 1;                   //
     307  int @n = nvars(basering);     // Zahl der Ringvariablen
     308  poly @f3 = jet(@f, 3);        // 3-Jet von f
     309  poly @fk;                     // k-Jet von f mit Gewichten
     310  ideal @JetId;                 // Ideal fuer Gewichteten Jet
     311  ideal @Jf;                    // jacob(@fk)
     312  int  @Dim;                    // dim(@Jf)
     313  int  @Mult;                   // mult(@Jf)
     314  int @k = 1;                   //
    363315
    364316  debug_log(1, "   Schritt 6");
     
    420372  return("","Fehler!");
    421373}
    422 //=============================================================================
     374///////////////////////////////////////////////////////////////////////////////
    423375//proc Funktion13 - put here
    424376//=========================================================================
    425377// Id: lib_WorkOn,v 1.8 1995/01/27 12:53:11 krueger Exp
    426378//
    427 //=============================================================================
     379///////////////////////////////////////////////////////////////////////////////
    428380//
    429381
     
    455407  return("","Fehler!");
    456408}
    457 //=============================================================================
    458 //=============================================================================
     409///////////////////////////////////////////////////////////////////////////////
     410///////////////////////////////////////////////////////////////////////////////
    459411proc Funktion17 (poly @f, int corank)
    460412USAGE:    Funktion17();
     
    474426    @f = Isomorphie_s17(@f, @fk, @p, 1);
    475427    if ( @p>1) {
    476       @JetId = x(1)^3*x(2) + x(2)^(3*@p);       // weight(@JetId);
     428      @JetId = x(1)^3*x(2) + x(2)^(3*@p);       // weight(@JetId);
    477429      @fk = jet(@f, 3*@p, weight(@JetId));
    478430    }
     
    506458  return("","Fehler!");
    507459}
    508 //=============================================================================
     460///////////////////////////////////////////////////////////////////////////////
    509461proc Funktion25 (poly @f, int CoRang)
    510462USAGE:    Funktion25();
     
    594546  return("","Fehler!"):
    595547}
    596 //=============================================================================
     548///////////////////////////////////////////////////////////////////////////////
    597549proc Funktion40  (poly @f, int @k)
    598550USAGE:    Funktion40();
     
    678630 return("","Fehler!");
    679631}
    680 //=============================================================================
    681 //=============================================================================
     632///////////////////////////////////////////////////////////////////////////////
     633///////////////////////////////////////////////////////////////////////////////
    682634//proc Funktion50 - put here
    683635//=========================================================================
     
    686638// Please send bugs and comments to krueger@mathematik.uni-kl.de
    687639//
    688 //=============================================================================
     640///////////////////////////////////////////////////////////////////////////////
    689641
    690642LIB "elim.lib";
     
    737689  return("","Fehler!");
    738690}
    739 //=============================================================================
     691///////////////////////////////////////////////////////////////////////////////
    740692proc Funktion51 (poly @f, int @k)
    741693USAGE:    Funktion51();
     
    748700  return(Show(@f), @tp);
    749701}
    750 //=============================================================================
     702///////////////////////////////////////////////////////////////////////////////
    751703proc Funktion52 (poly @f, int @k)
    752704USAGE:    Funktion52();
     
    760712  return(Show(@f), @tp);
    761713}
    762 //=============================================================================
     714///////////////////////////////////////////////////////////////////////////////
    763715proc Funktion54 (poly @f, int @k)
    764716USAGE:    Funktion54();
     
    772724  return(Show(@f), @tp);
    773725}
    774 //=============================================================================
     726///////////////////////////////////////////////////////////////////////////////
    775727proc Funktion56 (poly @f, int @k)
    776728USAGE:    Funktion56();
     
    784736  return(Show(@f), @tp);
    785737}
    786 //=============================================================================
     738///////////////////////////////////////////////////////////////////////////////
    787739proc Funktion58 (poly @fin, int @k)
    788740USAGE:    Funktion58();
     
    884836
    885837//--------------------------------------------------------------
    886 // fuehre nun Tschirnhaus in der Variablen 'z' durch und erhalte
     838// fuehre nun tschirnhaus in der Variablen 'z' durch und erhalte
    887839// f = f_1(x,y,z)y^2 + z^3
    888840//
     
    891843  @fb=@C[2,1];  // Coeff von x^1
    892844  @fc=@C[1,1];  // Coeff von x^0
    893   @fc, VERT = Tschirnhaus(@fc, x(@kz));
     845  @fc, VERT = tschirnhaus(@fc, x(@kz));
    894846  VERT;
    895847  @f = VERT(@f);
     
    957909}
    958910
    959 //=============================================================================
     911///////////////////////////////////////////////////////////////////////////////
    960912proc Funktion59 (poly @f, int @k)
    961913USAGE:    Funktion59();
     
    1031983}
    1032984
    1033 //=============================================================================
     985///////////////////////////////////////////////////////////////////////////////
    1034986proc Funktion66 (poly @f, int @k)
    1035987USAGE:    Funktion66();
     
    10581010  "nach z:",Show(@fz), "  Id=", @JetId, "  Dim=", dim(@JetId);
    10591011}
    1060 //=============================================================================
     1012///////////////////////////////////////////////////////////////////////////////
    10611013proc Funktion82 (poly @f, int @k)
    10621014USAGE:    Funktion82();
     
    11291081debug_log(2, "Fall: ", @Fall, "  x=", @kx, "  z=", @kz);
    11301082    map VERT;
    1131     if(@Fall == 2) { @b1, VERT = Tschirnhaus(@f3/x(@kz), x(@kx)); }
     1083    if(@Fall == 2) { @b1, VERT = tschirnhaus(@f3/x(@kz), x(@kx)); }
    11321084    else {
    1133       @b1, VERT = Tschirnhaus(@f3/x(@kx), x(@kx));
     1085      @b1, VERT = tschirnhaus(@f3/x(@kx), x(@kx));
    11341086      debug_log(2, "B1=", Show(jet(VERT(@f),3)));
    1135       @b2, VERT = Tschirnhaus(@f3/x(@kz), x(@kz));
     1087      @b2, VERT = tschirnhaus(@f3/x(@kz), x(@kz));
    11361088      debug_log(2, "B2=", Show(jet(VERT(@f),3)));
    11371089    }
     
    11391091    @f3 = jet(@f,3);
    11401092    debug_log(2, "2)f3=", Show(@f3));
    1141 //  @f3, VERT = Tschirnhaus(@f3, x(1));
     1093//  @f3, VERT = tschirnhaus(@f3, x(1));
    11421094    debug_log(2, "3)f3=", Show(jet(@f,3)));
    11431095//  }
     
    11491101  return("", "Fehler");
    11501102}
    1151 //=============================================================================
     1103///////////////////////////////////////////////////////////////////////////////
    11521104proc Isomorphie_s82_z (poly @f, poly @fk, int @p)
    11531105USAGE:    Isomorphie_s82_z();
     
    11731125}
    11741126
    1175 //=============================================================================
     1127///////////////////////////////////////////////////////////////////////////////
    11761128proc Isomorphie_s82_x (poly @f, poly @fk, int @p)
    11771129USAGE:    Isomorphie_s82_x();
     
    11971149  return(@f);
    11981150}
    1199 //=============================================================================
     1151///////////////////////////////////////////////////////////////////////////////
    12001152proc Funktion83 (poly @f, int @k)
    12011153USAGE:    Funktion83();
     
    12851237}
    12861238
    1287 //=============================================================================
     1239///////////////////////////////////////////////////////////////////////////////
    12881240proc Funktion97 (poly @f, int @K)
    12891241USAGE:    Funktion97();
     
    13791331  return(Show(@f), "V[k,r]");
    13801332}
    1381 //=============================================================================
     1333///////////////////////////////////////////////////////////////////////////////
    13821334proc Funktion103 (poly @f)
    13831335USAGE:    Funktion103();
     
    13851337  return(FunktionNoClass(@f,"3-jet = x3"));
    13861338}
    1387 //=============================================================================
     1339///////////////////////////////////////////////////////////////////////////////
    13881340proc Funktion104 (poly @f)
    13891341USAGE:    Funktion104();
     
    13911343  return(FunktionNoClass(@f));
    13921344}
    1393 //=============================================================================
     1345///////////////////////////////////////////////////////////////////////////////
    13941346proc Funktion105 (poly @f);
    13951347USAGE:    Funktion105();
     
    13971349  return(FunktionNoClass(@f));
    13981350}
    1399 //=============================================================================
     1351///////////////////////////////////////////////////////////////////////////////
    14001352proc FunktionNoClass (poly @f, list #)
    14011353USAGE:    FunktionNoClass();
     
    14111363  return(Show(@f), @s);
    14121364}
    1413 //=============================================================================
    1414 //=============================================================================
    1415 proc Tschirnhaus (poly @f, poly @x)
    1416 USAGE:    Tschirnhaus();
     1365///////////////////////////////////////////////////////////////////////////////
     1366///////////////////////////////////////////////////////////////////////////////
     1367proc tschirnhaus (poly @f, poly @x)
     1368USAGE:    tschirnhaus();
    14171369{
    14181370  int @n = nvars(basering);
    14191371  int @j;
    14201372
    1421 // "Tschirnhaus fuer:", Show(@f);
     1373// "tschirnhaus fuer:", Show(@f);
    14221374  matrix @cf = coeffs(@f, @x);
    14231375  int @hc = nrows(@cf) - 1;     // hoechster exponent von x_i
     
    14401392  return(@Phi(@f), @Phi);
    14411393}
    1442 //=============================================================================
    1443 //=============================================================================
     1394///////////////////////////////////////////////////////////////////////////////
     1395///////////////////////////////////////////////////////////////////////////////
    14441396proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct)
    14451397USAGE:    Isomorphie_s17();
     
    15951547// Please send bugs and comments to krueger@mathematik.uni-kl.de
    15961548//
    1597 //=============================================================================
     1549///////////////////////////////////////////////////////////////////////////////
    15981550// required libraries
    15991551
    1600 //=============================================================================
     1552///////////////////////////////////////////////////////////////////////////////
    16011553// required by
    16021554// LIB "Classify.lib"
    16031555// LIB "Kclass.lib"
    16041556
    1605 //=========================================================================
    1606 proc Ausgaben_lib
    1607 {
    1608 "
    1609   Funktion2(poly f,int k);      (for internal use only)
    1610   Funktion4(poly f,int k);      (for internal use only)
    1611   Funktion5(poly f,int k);      (for internal use only)
    1612   Funktion7(poly f,int k);      (for internal use only)
    1613   Funktion8(poly f,int k);      (for internal use only)
    1614   Funktion9(poly f,int k);      (for internal use only)
    1615   Funktion11(poly f,int k);     (for internal use only)
    1616   Funktion12(poly f,int k);     (for internal use only)
    1617   Funktion14(poly f,int k);     (for internal use only)
    1618   Funktion15(poly f,int k);     (for internal use only)
    1619   Funktion16(poly f,int k);     (for internal use only)
    1620   Funktion19(poly f,int k);     (for internal use only)
    1621   Funktion20(poly f,int k);     (for internal use only)
    1622   Funktion21(poly f,int k);     (for internal use only)
    1623   Funktion23(poly f,int k);     (for internal use only)
    1624   Funktion24(poly f,int k);     (for internal use only)
    1625   Funktion27(poly f,int k);     (for internal use only)
    1626   Funktion28(poly f,int k);     (for internal use only)
    1627   Funktion30(poly f,int k);     (for internal use only)
    1628   Funktion31(poly f,int k);     (for internal use only)
    1629   Funktion32(poly f,int k);     (for internal use only)
    1630   Funktion34(poly f,int k);     (for internal use only)
    1631   Funktion35(poly f,int k);     (for internal use only)
    1632   Funktion37(poly f,int k);     (for internal use only)
    1633   Funktion38(poly f,int k);     (for internal use only)
    1634   Funktion39(poly f,int k);     (for internal use only)
    1635   Funktion42(poly f,int k);     (for internal use only)
    1636   Funktion43(poly f,int k);     (for internal use only)
    1637   Funktion44(poly f,int k);     (for internal use only)
    1638   Funktion45(poly f,int k);     (for internal use only)
    1639   Funktion47(poly f,int k);     (for internal use only)
    1640   Funktion60(poly f,int k);     (for internal use only)
    1641   Funktion61(poly f,int k);     (for internal use only)
    1642   Funktion62(poly f,int k);     (for internal use only)
    1643   Funktion64(poly f,int k);     (for internal use only)
    1644   Funktion65(poly f,int k);     (for internal use only)
    1645   Funktion100(poly f,int k);    (for internal use only)
    1646   Funktion101(poly f,int k);    (for internal use only)
    1647 ";
    1648 }
    1649 
    1650 //=============================================================================
    1651 proc Funktion2
     1557///////////////////////////////////////////////////////////////////////////////
     1558proc Funktion2 (poly @f, int corank)
    16521559USAGE:   
    16531560{
     
    16621569  return(string(x^(Mu+1)), @tp);
    16631570}
    1664 //=============================================================================
     1571///////////////////////////////////////////////////////////////////////////////
    16651572proc Funktion4
    16661573USAGE:   
     
    16741581  return(Show(@f), @tp);
    16751582}
    1676 //=============================================================================
     1583///////////////////////////////////////////////////////////////////////////////
    16771584proc Funktion5
    16781585USAGE:   
     
    16861593  return(Show(@f), @tp);
    16871594}
    1688 //=============================================================================
     1595///////////////////////////////////////////////////////////////////////////////
    16891596proc Funktion7
    16901597USAGE:   
     
    17001607  return(Show(@f), @tp);
    17011608}
    1702 //=============================================================================
     1609///////////////////////////////////////////////////////////////////////////////
    17031610proc Funktion8
    17041611USAGE:   
     
    17141621  return(Show(@f), @tp);
    17151622}
    1716 //=============================================================================
     1623///////////////////////////////////////////////////////////////////////////////
    17171624proc Funktion9
    17181625USAGE:   
     
    17281635  return(Show(@f), @tp);
    17291636}
    1730 //=============================================================================
     1637///////////////////////////////////////////////////////////////////////////////
    17311638proc Funktion11
    17321639USAGE:   
     
    17421649  return(Show(@f), @tp);
    17431650}
    1744 //=============================================================================
     1651///////////////////////////////////////////////////////////////////////////////
    17451652proc Funktion12
    17461653USAGE:   
     
    17571664  return(Show(@f), @tp);
    17581665}
    1759 //=============================================================================
     1666///////////////////////////////////////////////////////////////////////////////
    17601667proc Funktion14
    17611668USAGE:   
     
    17701677  return(Show(@f), @tp);
    17711678}
    1772 //=============================================================================
     1679///////////////////////////////////////////////////////////////////////////////
    17731680proc Funktion15
    17741681USAGE:   
     
    17841691  return(Show(@f), @tp);
    17851692}
    1786 //=============================================================================
     1693///////////////////////////////////////////////////////////////////////////////
    17871694proc Funktion16
    17881695USAGE:   
     
    18001707  return(Show(@f), @tp);
    18011708}
    1802 //=============================================================================
     1709///////////////////////////////////////////////////////////////////////////////
    18031710proc Funktion19
    18041711USAGE:   
     
    18131720  return(Show(@f), @tp);
    18141721}
    1815 //=============================================================================
     1722///////////////////////////////////////////////////////////////////////////////
    18161723proc Funktion20
    18171724USAGE:   
     
    18261733  return(Show(@f), @tp);
    18271734}
    1828 //=============================================================================
     1735///////////////////////////////////////////////////////////////////////////////
    18291736proc Funktion21
    18301737USAGE:   
     
    18391746  return(Show(@f), @tp);
    18401747}
    1841 //=============================================================================
     1748///////////////////////////////////////////////////////////////////////////////
    18421749proc Funktion23
    18431750USAGE:   
     
    18521759  return(Show(@f), @tp);
    18531760}
    1854 //=============================================================================
     1761///////////////////////////////////////////////////////////////////////////////
    18551762proc Funktion24
    18561763USAGE:   
     
    18661773  return(Show(@f), @tp);
    18671774}
    1868 //=============================================================================
     1775///////////////////////////////////////////////////////////////////////////////
    18691776proc Funktion27
    18701777USAGE:   
     
    18791786  return(Show(@f), @tp);
    18801787}
    1881 //=============================================================================
     1788///////////////////////////////////////////////////////////////////////////////
    18821789proc Funktion28
    18831790USAGE:   
     
    18921799  return(Show(@f), @tp);
    18931800}
    1894 //=============================================================================
     1801///////////////////////////////////////////////////////////////////////////////
    18951802proc Funktion30
    18961803USAGE:   
     
    19051812  return(Show(@f), @tp);
    19061813}
    1907 //=============================================================================
     1814///////////////////////////////////////////////////////////////////////////////
    19081815proc Funktion31
    19091816USAGE:   
     
    19191826  return(Show(@f), @tp);
    19201827}
    1921 //=============================================================================
     1828///////////////////////////////////////////////////////////////////////////////
    19221829proc Funktion32
    19231830USAGE:   
     
    19331840  return(Show(@f), @tp);
    19341841}
    1935 //=============================================================================
     1842///////////////////////////////////////////////////////////////////////////////
    19361843proc Funktion34
    19371844USAGE:   
     
    19461853  return(Show(@f), @tp);
    19471854}
    1948 //=============================================================================
     1855///////////////////////////////////////////////////////////////////////////////
    19491856proc Funktion35
    19501857USAGE:   
     
    19591866  return(Show(@f), @tp);
    19601867}
    1961 //=============================================================================
     1868///////////////////////////////////////////////////////////////////////////////
    19621869proc Funktion37
    19631870USAGE:   
     
    19721879  return(Show(@f), @tp);
    19731880}
    1974 //=============================================================================
     1881///////////////////////////////////////////////////////////////////////////////
    19751882proc Funktion38
    19761883USAGE:   
     
    19861893  return(Show(@f), @tp);
    19871894}
    1988 //=============================================================================
     1895///////////////////////////////////////////////////////////////////////////////
    19891896proc Funktion39
    19901897USAGE:   
     
    19991906  return(Show(@f), @tp);
    20001907}
    2001 //=============================================================================
     1908///////////////////////////////////////////////////////////////////////////////
    20021909proc Funktion42
    20031910USAGE:   
     
    20131920  return(Show(@f), @tp);
    20141921}
    2015 //=============================================================================
     1922///////////////////////////////////////////////////////////////////////////////
    20161923proc Funktion43
    20171924USAGE:   
     
    20271934  return(Show(@f), @tp);
    20281935}
    2029 //=============================================================================
     1936///////////////////////////////////////////////////////////////////////////////
    20301937proc Funktion44
    20311938USAGE:   
     
    20411948  return(Show(@f), @tp);
    20421949}
    2043 //=============================================================================
     1950///////////////////////////////////////////////////////////////////////////////
    20441951proc Funktion45
    20451952USAGE:   
     
    20561963  return(Show(@f), @tp);
    20571964}
    2058 //=============================================================================
     1965///////////////////////////////////////////////////////////////////////////////
    20591966proc Funktion47
    20601967USAGE:   
     
    20721979  return(Show(@f), @tp);
    20731980}
    2074 //=============================================================================
     1981///////////////////////////////////////////////////////////////////////////////
    20751982proc Funktion60
    20761983USAGE:   
     
    20851992  return(Show(@f), @tp);
    20861993}
    2087 //=============================================================================
     1994///////////////////////////////////////////////////////////////////////////////
    20881995proc Funktion61
    20891996USAGE:   
     
    20982005  return(Show(@f), @tp);
    20992006}
    2100 //=============================================================================
     2007///////////////////////////////////////////////////////////////////////////////
    21012008proc Funktion62
    21022009USAGE:   
     
    21112018  return(Show(@f), @tp);
    21122019}
    2113 //=============================================================================
     2020///////////////////////////////////////////////////////////////////////////////
    21142021proc Funktion64
    21152022USAGE:   
     
    21242031  return(Show(@f), @tp);
    21252032}
    2126 //=============================================================================
     2033///////////////////////////////////////////////////////////////////////////////
    21272034proc Funktion65
    21282035USAGE:   
     
    21382045  return(Show(@f), @tp);
    21392046}
    2140 //=============================================================================
     2047///////////////////////////////////////////////////////////////////////////////
    21412048proc Funktion84
    21422049USAGE:   
     
    21482055  return(FunktionNoClass(#[1]));
    21492056}
    2150 //=============================================================================
     2057///////////////////////////////////////////////////////////////////////////////
    21512058proc Funktion86
    21522059USAGE:   
     
    21582065  return(FunktionNoClass(#[1]));
    21592066}
    2160 //=============================================================================
     2067///////////////////////////////////////////////////////////////////////////////
    21612068proc Funktion87
    21622069USAGE:   
     
    21682075  return(FunktionNoClass(#[1]));
    21692076}
    2170 //=============================================================================
     2077///////////////////////////////////////////////////////////////////////////////
    21712078proc Funktion89
    21722079USAGE:   
     
    21782085  return(FunktionNoClass(#[1]));
    21792086}
    2180 //=============================================================================
     2087///////////////////////////////////////////////////////////////////////////////
    21812088proc Funktion100
    21822089USAGE:   
     
    21922099  return(Show(@f), @tp);
    21932100}
    2194 //=============================================================================
     2101///////////////////////////////////////////////////////////////////////////////
    21952102proc Funktion101
    21962103USAGE:   
     
    22062113  return(Show(@f), @tp);
    22072114}
    2208 //=============================================================================
     2115///////////////////////////////////////////////////////////////////////////////
     2116proc internalfunctions
     2117USAGE:   internalfunctions();
     2118RETURN:  nothing, display names of internal procedures of classify.lib
     2119EXAMPLE: no example
     2120{ "   Internal functions for the classification unsing Arnold's method:
     2121  Klassifiziere(poly f);             determine the typ of the singularity f
     2122  Funktion1bis (poly @f, int corank)
     2123  Funktion2 (poly f,int k)
     2124  Funktion3 (poly @f, int corank);
     2125  Funktion4 (poly f,int k)
     2126  Funktion5 (poly f,int k)
     2127  Funktion6 (poly @f, int corank)
     2128  Funktion7 (poly f,int k)
     2129  Funktion8 (poly f,int k)
     2130  Funktion9 (poly f,int k)
     2131  Funktion11 (poly f,int k)
     2132  Funktion12 (poly f,int k)
     2133  Funktion13 (poly @f, int corank)
     2134  Funktion14 (poly f,int k)
     2135  Funktion15 (poly f,int k)
     2136  Funktion16 (poly f,int k)
     2137  Funktion17 (poly @f, int corank)
     2138  Funktion19 (poly f,int k)
     2139  Funktion20 (poly f,int k)
     2140  Funktion21 (poly f,int k)
     2141  Funktion23 (poly f,int k)
     2142  Funktion24 (poly f,int k)
     2143  Funktion25 (poly @f, int CoRang)
     2144  Funktion27 (poly f,int k)
     2145  Funktion28 (poly f,int k)
     2146  Funktion30 (poly f,int k)
     2147  Funktion31 (poly f,int k)
     2148  Funktion32 (poly f,int k)
     2149  Funktion34 (poly f,int k)
     2150  Funktion35 (poly f,int k)
     2151  Funktion37 (poly f,int k)
     2152  Funktion38 (poly f,int k)
     2153  Funktion39 (poly f,int k)
     2154  Funktion40 (poly @f, int @k)
     2155  Funktion42 (poly f,int k)
     2156  Funktion43 (poly f,int k)
     2157  Funktion44 (poly f,int k)
     2158  Funktion45 (poly f,int k)
     2159  Funktion47 (poly f,int k)
     2160  Funktion50 (poly @f, int corank)
     2161  Funktion51 (poly @f, int @k)
     2162  Funktion52 (poly @f, int @k)
     2163  Funktion54 (poly @f, int @k)
     2164  Funktion56 (poly @f, int @k)
     2165  Funktion58 (poly @fin, int @k)
     2166  Funktion59 (poly @f, int @k)
     2167  Funktion60 (poly f,int k)
     2168  Funktion61 (poly f,int k)
     2169  Funktion62 (poly f,int k)
     2170  Funktion64 (poly f,int k)
     2171  Funktion65 (poly f,int k)
     2172  Funktion66 (poly @f, int @k)
     2173  Funktion82 (poly @f, int @k)
     2174  Funktion83 (poly @f, int @k)
     2175  Funktion84 (poly f,int k)
     2176  Funktion86 (poly f,int k)
     2177  Funktion87 (poly f,int k)
     2178  Funktion89 (poly f,int k)
     2179  Funktion97 (poly @f, int @K)
     2180  Funktion100 (poly f,int k)
     2181  Funktion101 (poly f,int k)
     2182
     2183  Funktion103(poly f, int corank);
     2184  Funktion104(poly f, int corank);
     2185  Funktion105(poly f, int corank);
     2186  FunktionNoClass(poly f, int corank);
     2187  Isomorphie_s82_x(poly f, poly fk, int k);
     2188  Isomorphie_s82_z(poly f, poly fk, int k);
     2189  tschirnhaus(poly f, int corank);
     2190  Isomorphie_s17 (poly f, poly fk, int k, int ct);
     2191  ";
     2192  "   Internal functions for the classifcation by invariants:
     2193  ";
     2194  "   Internal functions for the Morse-splitting lemma:
     2195  ";
     2196  "   Internal functions providing tools:
     2197  ";
     2198}
     2199///////////////////////////////////////////////////////////////////////////////
    22092200// E n d   O f   F i l e
     2201//proc Ausgaben_lib
     2202//proc Funktion103 (poly @f)
     2203//proc Funktion104 (poly @f)
     2204//proc Funktion105 (poly @f);
     2205
     2206//proc FunktionNoClass (poly @f, list #)
     2207//proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct)
     2208//proc Isomorphie_s82_x (poly @f, poly @fk, int @p)
     2209//proc Isomorphie_s82_z (poly @f, poly @fk, int @p)
     2210//proc Klassifiziere (poly @f)
     2211//proc classify (poly f_in)
     2212//proc internalfunctions
     2213//proc tschirnhaus (poly @f, poly @x)
Note: See TracChangeset for help on using the changeset viewer.