Changeset 03645f4 in git
- Timestamp:
- Sep 26, 1997, 10:14:35 AM (27 years ago)
- Branches:
- (u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')
- Children:
- f0596e3b7b21bb03a5e31efdb572b2f9e62183e1
- Parents:
- 99712fe05cf5af352d82d7cd058e186881446a54
- 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 $ 3 2 // 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: 5 9 // 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 12 LIBRARY: classify.lib PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES 13 14 classify(f); normal form of poly f determined with Arnold's method 15 quickclass(f) normal form of f determined by invariants (milnorcode) 16 corank(f); computes the corank of f (i.e. of the Hessian of f) 17 basicinvariants(f); computes Milnor number, determinacy-bound and corank of f 18 milnorcode(f[,e]); Hilbert poly of [e-th] Milnor algebra coded with Hcode 19 Hcode(v); coding of intvec v acoording to the number repetitions 20 morsesplit(f); residual part of f after applying the splitting lemma 21 tschirnhaus(f,v); Tschirnhaus transformation of f w.r.t. variable v 22 singinfo(N,[k,]); info about singularity given by its name N and index k 23 singularity(s,[]); normal form of singularity given by its name s and index 24 init_debug([n]); print trace and debugging information depending on int n 25 internalfunctions(); display names of internal procedures of this library 26 (parameters in square brackets [] are optional) 27 28 LIB "inout.lib"; 40 29 41 30 // required libraries … … 46 35 LIB "hilbert.lib"; 47 36 48 //============================================================================= 37 /////////////////////////////////////////////////////////////////////////////// 38 //--------------------------- output ------------------------------------------ 39 /////////////////////////////////////////////////////////////////////////////// 49 40 //============================================================================= 50 41 // TopLevel Funktion of the Arnold-Classifier. 51 42 // 52 proc classify (poly @f_in)43 proc classify (poly f_in) 53 44 USAGE: classify(f); f=poly 54 45 COMPUTE: Normalform and singularity type of f … … 59 50 "Kai Krueger" <krueger@mathematik.uni-kl.de> 60 51 NOTE: The procedure init_debug(n); is usefull as trace-mode. 61 52 n may range from 0 to 10, higher values of n give more information. 62 53 { 63 54 // or set the shell-variable SG_DEBUG to the debugging level. … … 73 64 export CharOfRing; 74 65 75 if(checkring()) { return( @f_in); }66 if(checkring()) { return(f_in); } 76 67 int @show_nf = 1; // return normal form if set to '1' 77 68 … … 104 95 string @s2; 105 96 string @s4; 106 @s1,@s2=Klassifiziere(@Conv( @f_in));97 @s1,@s2=Klassifiziere(@Conv(f_in)); 107 98 // @s1: f nach saemtlichen Koordinatentransformationen 108 99 // @s2: Typ des Polynoms f z.b: E[18] … … 115 106 if(@s1=="1" || @s2[1,4]=="The " || @s2=="Fehler!" ) { 116 107 setring ring_top; 117 return( @f_in);108 return(f_in); 118 109 } 119 110 setring Rtop; … … 155 146 //============================================================================= 156 147 // 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.de160 //161 //=============================================================================162 163 //=========================================================================164 proc Kclass_lib165 {166 "167 Klassifiziere(poly f); determine the typ of the singularity f168 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 196 148 //============================================================================= 197 149 proc Klassifiziere (poly @f) … … 203 155 // Wenn nicht geht's einfach nicht. Hans fragen! 204 156 init(1); 205 int @n = nvars(basering); 157 int @n = nvars(basering); // Zahl der Variablen des aktuellen Rings. 206 158 207 159 // Define always 'RingDisplay' to be able to run 'Show(f)' … … 218 170 // 219 171 @s1 = "ring RingB="+string(CharOfRing)+",("+A_Z("x", @n)+"),ds;"; 220 execute @s1; 172 execute @s1; // in diesem Ring werden Polynome angezeigt. 221 173 @s1 = "map ShowPoly=Rtop,"+A_Z("x", @n)+";"; 222 execute @s1; 174 execute @s1; // Hiermit werden Polynome angezeigt. 223 175 export ShowPoly; 224 setring Rtop; 176 setring Rtop; // in den Ausgangs-ring zurueck. 225 177 export RingB; 226 178 … … 274 226 return(Funktion105(@f, CoRang)); 275 227 } 276 // =============================================================================228 /////////////////////////////////////////////////////////////////////////////// 277 229 proc Funktion1bis (poly @f, int corank) 278 230 USAGE: Funktion1bis(); … … 325 277 return("","Fehler!"); 326 278 } 327 // =============================================================================279 /////////////////////////////////////////////////////////////////////////////// 328 280 proc Funktion3 (poly @f, int corank); 329 281 USAGE: Funktion3(); … … 344 296 if( mult(@Jf) == 2) { return(Funktion6(@f, corank)); } // E[k], J 345 297 "dimension 1 und deg != 1, 2 => error, this should never occur"; 346 return("", "Fehler!"); 347 } 348 return("", "Fehler!"); 349 } 350 // =============================================================================298 return("", "Fehler!"); // Should never occur 299 } 300 return("", "Fehler!"); // Should never occur 301 } 302 /////////////////////////////////////////////////////////////////////////////// 351 303 //proc Funktion6 - put here 352 304 proc Funktion6 (poly @f, int corank) 353 305 USAGE: Funktion6() 354 306 { 355 int @n = nvars(basering); 356 poly @f3 = jet(@f, 3); 357 poly @fk; 358 ideal @JetId; 359 ideal @Jf; 360 int @Dim; 361 int @Mult; 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; // 363 315 364 316 debug_log(1, " Schritt 6"); … … 420 372 return("","Fehler!"); 421 373 } 422 // =============================================================================374 /////////////////////////////////////////////////////////////////////////////// 423 375 //proc Funktion13 - put here 424 376 //========================================================================= 425 377 // Id: lib_WorkOn,v 1.8 1995/01/27 12:53:11 krueger Exp 426 378 // 427 // =============================================================================379 /////////////////////////////////////////////////////////////////////////////// 428 380 // 429 381 … … 455 407 return("","Fehler!"); 456 408 } 457 // =============================================================================458 // =============================================================================409 /////////////////////////////////////////////////////////////////////////////// 410 /////////////////////////////////////////////////////////////////////////////// 459 411 proc Funktion17 (poly @f, int corank) 460 412 USAGE: Funktion17(); … … 474 426 @f = Isomorphie_s17(@f, @fk, @p, 1); 475 427 if ( @p>1) { 476 @JetId = x(1)^3*x(2) + x(2)^(3*@p); 428 @JetId = x(1)^3*x(2) + x(2)^(3*@p); // weight(@JetId); 477 429 @fk = jet(@f, 3*@p, weight(@JetId)); 478 430 } … … 506 458 return("","Fehler!"); 507 459 } 508 // =============================================================================460 /////////////////////////////////////////////////////////////////////////////// 509 461 proc Funktion25 (poly @f, int CoRang) 510 462 USAGE: Funktion25(); … … 594 546 return("","Fehler!"): 595 547 } 596 // =============================================================================548 /////////////////////////////////////////////////////////////////////////////// 597 549 proc Funktion40 (poly @f, int @k) 598 550 USAGE: Funktion40(); … … 678 630 return("","Fehler!"); 679 631 } 680 // =============================================================================681 // =============================================================================632 /////////////////////////////////////////////////////////////////////////////// 633 /////////////////////////////////////////////////////////////////////////////// 682 634 //proc Funktion50 - put here 683 635 //========================================================================= … … 686 638 // Please send bugs and comments to krueger@mathematik.uni-kl.de 687 639 // 688 // =============================================================================640 /////////////////////////////////////////////////////////////////////////////// 689 641 690 642 LIB "elim.lib"; … … 737 689 return("","Fehler!"); 738 690 } 739 // =============================================================================691 /////////////////////////////////////////////////////////////////////////////// 740 692 proc Funktion51 (poly @f, int @k) 741 693 USAGE: Funktion51(); … … 748 700 return(Show(@f), @tp); 749 701 } 750 // =============================================================================702 /////////////////////////////////////////////////////////////////////////////// 751 703 proc Funktion52 (poly @f, int @k) 752 704 USAGE: Funktion52(); … … 760 712 return(Show(@f), @tp); 761 713 } 762 // =============================================================================714 /////////////////////////////////////////////////////////////////////////////// 763 715 proc Funktion54 (poly @f, int @k) 764 716 USAGE: Funktion54(); … … 772 724 return(Show(@f), @tp); 773 725 } 774 // =============================================================================726 /////////////////////////////////////////////////////////////////////////////// 775 727 proc Funktion56 (poly @f, int @k) 776 728 USAGE: Funktion56(); … … 784 736 return(Show(@f), @tp); 785 737 } 786 // =============================================================================738 /////////////////////////////////////////////////////////////////////////////// 787 739 proc Funktion58 (poly @fin, int @k) 788 740 USAGE: Funktion58(); … … 884 836 885 837 //-------------------------------------------------------------- 886 // fuehre nun Tschirnhaus in der Variablen 'z' durch und erhalte838 // fuehre nun tschirnhaus in der Variablen 'z' durch und erhalte 887 839 // f = f_1(x,y,z)y^2 + z^3 888 840 // … … 891 843 @fb=@C[2,1]; // Coeff von x^1 892 844 @fc=@C[1,1]; // Coeff von x^0 893 @fc, VERT = Tschirnhaus(@fc, x(@kz));845 @fc, VERT = tschirnhaus(@fc, x(@kz)); 894 846 VERT; 895 847 @f = VERT(@f); … … 957 909 } 958 910 959 // =============================================================================911 /////////////////////////////////////////////////////////////////////////////// 960 912 proc Funktion59 (poly @f, int @k) 961 913 USAGE: Funktion59(); … … 1031 983 } 1032 984 1033 // =============================================================================985 /////////////////////////////////////////////////////////////////////////////// 1034 986 proc Funktion66 (poly @f, int @k) 1035 987 USAGE: Funktion66(); … … 1058 1010 "nach z:",Show(@fz), " Id=", @JetId, " Dim=", dim(@JetId); 1059 1011 } 1060 // =============================================================================1012 /////////////////////////////////////////////////////////////////////////////// 1061 1013 proc Funktion82 (poly @f, int @k) 1062 1014 USAGE: Funktion82(); … … 1129 1081 debug_log(2, "Fall: ", @Fall, " x=", @kx, " z=", @kz); 1130 1082 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)); } 1132 1084 else { 1133 @b1, VERT = Tschirnhaus(@f3/x(@kx), x(@kx));1085 @b1, VERT = tschirnhaus(@f3/x(@kx), x(@kx)); 1134 1086 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)); 1136 1088 debug_log(2, "B2=", Show(jet(VERT(@f),3))); 1137 1089 } … … 1139 1091 @f3 = jet(@f,3); 1140 1092 debug_log(2, "2)f3=", Show(@f3)); 1141 // @f3, VERT = Tschirnhaus(@f3, x(1));1093 // @f3, VERT = tschirnhaus(@f3, x(1)); 1142 1094 debug_log(2, "3)f3=", Show(jet(@f,3))); 1143 1095 // } … … 1149 1101 return("", "Fehler"); 1150 1102 } 1151 // =============================================================================1103 /////////////////////////////////////////////////////////////////////////////// 1152 1104 proc Isomorphie_s82_z (poly @f, poly @fk, int @p) 1153 1105 USAGE: Isomorphie_s82_z(); … … 1173 1125 } 1174 1126 1175 // =============================================================================1127 /////////////////////////////////////////////////////////////////////////////// 1176 1128 proc Isomorphie_s82_x (poly @f, poly @fk, int @p) 1177 1129 USAGE: Isomorphie_s82_x(); … … 1197 1149 return(@f); 1198 1150 } 1199 // =============================================================================1151 /////////////////////////////////////////////////////////////////////////////// 1200 1152 proc Funktion83 (poly @f, int @k) 1201 1153 USAGE: Funktion83(); … … 1285 1237 } 1286 1238 1287 // =============================================================================1239 /////////////////////////////////////////////////////////////////////////////// 1288 1240 proc Funktion97 (poly @f, int @K) 1289 1241 USAGE: Funktion97(); … … 1379 1331 return(Show(@f), "V[k,r]"); 1380 1332 } 1381 // =============================================================================1333 /////////////////////////////////////////////////////////////////////////////// 1382 1334 proc Funktion103 (poly @f) 1383 1335 USAGE: Funktion103(); … … 1385 1337 return(FunktionNoClass(@f,"3-jet = x3")); 1386 1338 } 1387 // =============================================================================1339 /////////////////////////////////////////////////////////////////////////////// 1388 1340 proc Funktion104 (poly @f) 1389 1341 USAGE: Funktion104(); … … 1391 1343 return(FunktionNoClass(@f)); 1392 1344 } 1393 // =============================================================================1345 /////////////////////////////////////////////////////////////////////////////// 1394 1346 proc Funktion105 (poly @f); 1395 1347 USAGE: Funktion105(); … … 1397 1349 return(FunktionNoClass(@f)); 1398 1350 } 1399 // =============================================================================1351 /////////////////////////////////////////////////////////////////////////////// 1400 1352 proc FunktionNoClass (poly @f, list #) 1401 1353 USAGE: FunktionNoClass(); … … 1411 1363 return(Show(@f), @s); 1412 1364 } 1413 // =============================================================================1414 // =============================================================================1415 proc Tschirnhaus (poly @f, poly @x)1416 USAGE: Tschirnhaus();1365 /////////////////////////////////////////////////////////////////////////////// 1366 /////////////////////////////////////////////////////////////////////////////// 1367 proc tschirnhaus (poly @f, poly @x) 1368 USAGE: tschirnhaus(); 1417 1369 { 1418 1370 int @n = nvars(basering); 1419 1371 int @j; 1420 1372 1421 // " Tschirnhaus fuer:", Show(@f);1373 // "tschirnhaus fuer:", Show(@f); 1422 1374 matrix @cf = coeffs(@f, @x); 1423 1375 int @hc = nrows(@cf) - 1; // hoechster exponent von x_i … … 1440 1392 return(@Phi(@f), @Phi); 1441 1393 } 1442 // =============================================================================1443 // =============================================================================1394 /////////////////////////////////////////////////////////////////////////////// 1395 /////////////////////////////////////////////////////////////////////////////// 1444 1396 proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct) 1445 1397 USAGE: Isomorphie_s17(); … … 1595 1547 // Please send bugs and comments to krueger@mathematik.uni-kl.de 1596 1548 // 1597 // =============================================================================1549 /////////////////////////////////////////////////////////////////////////////// 1598 1550 // required libraries 1599 1551 1600 // =============================================================================1552 /////////////////////////////////////////////////////////////////////////////// 1601 1553 // required by 1602 1554 // LIB "Classify.lib" 1603 1555 // LIB "Kclass.lib" 1604 1556 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 /////////////////////////////////////////////////////////////////////////////// 1558 proc Funktion2 (poly @f, int corank) 1652 1559 USAGE: 1653 1560 { … … 1662 1569 return(string(x^(Mu+1)), @tp); 1663 1570 } 1664 // =============================================================================1571 /////////////////////////////////////////////////////////////////////////////// 1665 1572 proc Funktion4 1666 1573 USAGE: … … 1674 1581 return(Show(@f), @tp); 1675 1582 } 1676 // =============================================================================1583 /////////////////////////////////////////////////////////////////////////////// 1677 1584 proc Funktion5 1678 1585 USAGE: … … 1686 1593 return(Show(@f), @tp); 1687 1594 } 1688 // =============================================================================1595 /////////////////////////////////////////////////////////////////////////////// 1689 1596 proc Funktion7 1690 1597 USAGE: … … 1700 1607 return(Show(@f), @tp); 1701 1608 } 1702 // =============================================================================1609 /////////////////////////////////////////////////////////////////////////////// 1703 1610 proc Funktion8 1704 1611 USAGE: … … 1714 1621 return(Show(@f), @tp); 1715 1622 } 1716 // =============================================================================1623 /////////////////////////////////////////////////////////////////////////////// 1717 1624 proc Funktion9 1718 1625 USAGE: … … 1728 1635 return(Show(@f), @tp); 1729 1636 } 1730 // =============================================================================1637 /////////////////////////////////////////////////////////////////////////////// 1731 1638 proc Funktion11 1732 1639 USAGE: … … 1742 1649 return(Show(@f), @tp); 1743 1650 } 1744 // =============================================================================1651 /////////////////////////////////////////////////////////////////////////////// 1745 1652 proc Funktion12 1746 1653 USAGE: … … 1757 1664 return(Show(@f), @tp); 1758 1665 } 1759 // =============================================================================1666 /////////////////////////////////////////////////////////////////////////////// 1760 1667 proc Funktion14 1761 1668 USAGE: … … 1770 1677 return(Show(@f), @tp); 1771 1678 } 1772 // =============================================================================1679 /////////////////////////////////////////////////////////////////////////////// 1773 1680 proc Funktion15 1774 1681 USAGE: … … 1784 1691 return(Show(@f), @tp); 1785 1692 } 1786 // =============================================================================1693 /////////////////////////////////////////////////////////////////////////////// 1787 1694 proc Funktion16 1788 1695 USAGE: … … 1800 1707 return(Show(@f), @tp); 1801 1708 } 1802 // =============================================================================1709 /////////////////////////////////////////////////////////////////////////////// 1803 1710 proc Funktion19 1804 1711 USAGE: … … 1813 1720 return(Show(@f), @tp); 1814 1721 } 1815 // =============================================================================1722 /////////////////////////////////////////////////////////////////////////////// 1816 1723 proc Funktion20 1817 1724 USAGE: … … 1826 1733 return(Show(@f), @tp); 1827 1734 } 1828 // =============================================================================1735 /////////////////////////////////////////////////////////////////////////////// 1829 1736 proc Funktion21 1830 1737 USAGE: … … 1839 1746 return(Show(@f), @tp); 1840 1747 } 1841 // =============================================================================1748 /////////////////////////////////////////////////////////////////////////////// 1842 1749 proc Funktion23 1843 1750 USAGE: … … 1852 1759 return(Show(@f), @tp); 1853 1760 } 1854 // =============================================================================1761 /////////////////////////////////////////////////////////////////////////////// 1855 1762 proc Funktion24 1856 1763 USAGE: … … 1866 1773 return(Show(@f), @tp); 1867 1774 } 1868 // =============================================================================1775 /////////////////////////////////////////////////////////////////////////////// 1869 1776 proc Funktion27 1870 1777 USAGE: … … 1879 1786 return(Show(@f), @tp); 1880 1787 } 1881 // =============================================================================1788 /////////////////////////////////////////////////////////////////////////////// 1882 1789 proc Funktion28 1883 1790 USAGE: … … 1892 1799 return(Show(@f), @tp); 1893 1800 } 1894 // =============================================================================1801 /////////////////////////////////////////////////////////////////////////////// 1895 1802 proc Funktion30 1896 1803 USAGE: … … 1905 1812 return(Show(@f), @tp); 1906 1813 } 1907 // =============================================================================1814 /////////////////////////////////////////////////////////////////////////////// 1908 1815 proc Funktion31 1909 1816 USAGE: … … 1919 1826 return(Show(@f), @tp); 1920 1827 } 1921 // =============================================================================1828 /////////////////////////////////////////////////////////////////////////////// 1922 1829 proc Funktion32 1923 1830 USAGE: … … 1933 1840 return(Show(@f), @tp); 1934 1841 } 1935 // =============================================================================1842 /////////////////////////////////////////////////////////////////////////////// 1936 1843 proc Funktion34 1937 1844 USAGE: … … 1946 1853 return(Show(@f), @tp); 1947 1854 } 1948 // =============================================================================1855 /////////////////////////////////////////////////////////////////////////////// 1949 1856 proc Funktion35 1950 1857 USAGE: … … 1959 1866 return(Show(@f), @tp); 1960 1867 } 1961 // =============================================================================1868 /////////////////////////////////////////////////////////////////////////////// 1962 1869 proc Funktion37 1963 1870 USAGE: … … 1972 1879 return(Show(@f), @tp); 1973 1880 } 1974 // =============================================================================1881 /////////////////////////////////////////////////////////////////////////////// 1975 1882 proc Funktion38 1976 1883 USAGE: … … 1986 1893 return(Show(@f), @tp); 1987 1894 } 1988 // =============================================================================1895 /////////////////////////////////////////////////////////////////////////////// 1989 1896 proc Funktion39 1990 1897 USAGE: … … 1999 1906 return(Show(@f), @tp); 2000 1907 } 2001 // =============================================================================1908 /////////////////////////////////////////////////////////////////////////////// 2002 1909 proc Funktion42 2003 1910 USAGE: … … 2013 1920 return(Show(@f), @tp); 2014 1921 } 2015 // =============================================================================1922 /////////////////////////////////////////////////////////////////////////////// 2016 1923 proc Funktion43 2017 1924 USAGE: … … 2027 1934 return(Show(@f), @tp); 2028 1935 } 2029 // =============================================================================1936 /////////////////////////////////////////////////////////////////////////////// 2030 1937 proc Funktion44 2031 1938 USAGE: … … 2041 1948 return(Show(@f), @tp); 2042 1949 } 2043 // =============================================================================1950 /////////////////////////////////////////////////////////////////////////////// 2044 1951 proc Funktion45 2045 1952 USAGE: … … 2056 1963 return(Show(@f), @tp); 2057 1964 } 2058 // =============================================================================1965 /////////////////////////////////////////////////////////////////////////////// 2059 1966 proc Funktion47 2060 1967 USAGE: … … 2072 1979 return(Show(@f), @tp); 2073 1980 } 2074 // =============================================================================1981 /////////////////////////////////////////////////////////////////////////////// 2075 1982 proc Funktion60 2076 1983 USAGE: … … 2085 1992 return(Show(@f), @tp); 2086 1993 } 2087 // =============================================================================1994 /////////////////////////////////////////////////////////////////////////////// 2088 1995 proc Funktion61 2089 1996 USAGE: … … 2098 2005 return(Show(@f), @tp); 2099 2006 } 2100 // =============================================================================2007 /////////////////////////////////////////////////////////////////////////////// 2101 2008 proc Funktion62 2102 2009 USAGE: … … 2111 2018 return(Show(@f), @tp); 2112 2019 } 2113 // =============================================================================2020 /////////////////////////////////////////////////////////////////////////////// 2114 2021 proc Funktion64 2115 2022 USAGE: … … 2124 2031 return(Show(@f), @tp); 2125 2032 } 2126 // =============================================================================2033 /////////////////////////////////////////////////////////////////////////////// 2127 2034 proc Funktion65 2128 2035 USAGE: … … 2138 2045 return(Show(@f), @tp); 2139 2046 } 2140 // =============================================================================2047 /////////////////////////////////////////////////////////////////////////////// 2141 2048 proc Funktion84 2142 2049 USAGE: … … 2148 2055 return(FunktionNoClass(#[1])); 2149 2056 } 2150 // =============================================================================2057 /////////////////////////////////////////////////////////////////////////////// 2151 2058 proc Funktion86 2152 2059 USAGE: … … 2158 2065 return(FunktionNoClass(#[1])); 2159 2066 } 2160 // =============================================================================2067 /////////////////////////////////////////////////////////////////////////////// 2161 2068 proc Funktion87 2162 2069 USAGE: … … 2168 2075 return(FunktionNoClass(#[1])); 2169 2076 } 2170 // =============================================================================2077 /////////////////////////////////////////////////////////////////////////////// 2171 2078 proc Funktion89 2172 2079 USAGE: … … 2178 2085 return(FunktionNoClass(#[1])); 2179 2086 } 2180 // =============================================================================2087 /////////////////////////////////////////////////////////////////////////////// 2181 2088 proc Funktion100 2182 2089 USAGE: … … 2192 2099 return(Show(@f), @tp); 2193 2100 } 2194 // =============================================================================2101 /////////////////////////////////////////////////////////////////////////////// 2195 2102 proc Funktion101 2196 2103 USAGE: … … 2206 2113 return(Show(@f), @tp); 2207 2114 } 2208 //============================================================================= 2115 /////////////////////////////////////////////////////////////////////////////// 2116 proc internalfunctions 2117 USAGE: internalfunctions(); 2118 RETURN: nothing, display names of internal procedures of classify.lib 2119 EXAMPLE: 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 /////////////////////////////////////////////////////////////////////////////// 2209 2200 // 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.