Changeset bb17e8 in git
 Timestamp:
 Mar 17, 1998, 4:06:35 PM (25 years ago)
 Branches:
 (u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
 Children:
 fc732a9d4c770726f143d87d99fa55800945885b
 Parents:
 6f5db891dcfcc0310e9d93a88bb7a41cff0e8529
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/hnoether.lib
r6f5db8 rbb17e8 1 // $Id: hnoether.lib,v 1.2 19980306 11:52:55 krueger Exp $ 2 // This library requires Singular 1.0 1 // $Id: hnoether.lib,v 1.3 19980317 15:06:35 Singular Exp $ 2 // author: Martin Lamm, email: lamm@mathematik.unikl.de 3 // last change: 13.03.98 3 4 /////////////////////////////////////////////////////////////////////////////// 4 5 … … 14 15 displayInvariants(hne); display invariants of f 15 16 generators(hne); computes the generators of the semigroup of values 17 intersection(hne1,hne2); intersection multiplicity of two curves 18 stripHNE(hne); reduce amount of memory consumed by hne 16 19 17 20 perhaps useful procedures: 18 21 puiseux2generators(m,n); convert puiseux pairs to generators of semigroup 22 multiplicities(hne); multiplicities of blowed up curves 19 23 newtonpoly(f); newtonpolygon of polynom f 20 24 newtonhoehne(f); same as newtonpoly, but uses internal procedure … … 80 84 } 81 85 /////////////////////////////////////////////////////////////////////////////// 82 proc T_Transform (poly f, int Q, int N) 86 proc T_Transform (poly f, int Q, int N) 83 87 // returns f(y,xy^Q)/y^NQ 84 88 { … … 87 91 } 88 92 /////////////////////////////////////////////////////////////////////////////// 89 proc T1_Transform (poly f, number d, int M) 93 proc T1_Transform (poly f, number d, int M) 90 94 // returns f(x,y+d*x^M) 91 95 { … … 102 106 int ggt=gcd(M,N); 103 107 M=M/ggt; N=N/ggt; 104 list ts=extgcd(M,N); 108 list ts=extgcd(M,N); 105 109 int tau,sigma=ts[2],ts[3]; 106 110 if (sigma<0) { tau=tau; sigma=sigma;} … … 130 134 poly hilf; 131 135 // dividiere f so lange durch x, wie die Div. aufgeht: 132 for (hilf=f/x; hilf*x==f; hilf=f/x) {f=hilf;} 136 for (hilf=f/x; hilf*x==f; hilf=f/x) {f=hilf;} 133 137 for (hilf=f/y; hilf*y==f; hilf=f/y) {f=hilf;} // gleiches fuer y 134 138 return(list(T1(f),d)); … … 142 146 { 143 147 matrix mat = coeffs(coeffs(f,y)[J+1,1],x); 144 if (size(mat) <= I) { return(0);} 148 if (size(mat) <= I) { return(0);} 145 149 else { return(leadcoef(mat[I+1,1]));} 146 150 } … … 164 168 // Rueckgabe evtl. nicht quadratfrei! Bsp.: squarefree((1/a*x3+y7)^3); 165 169 // in char 7 170 // In Singular 1.1.3 funktioniert syz, dafuer geht das gleiche Bsp. schief, 171 // weil gcd auf einmal falsch wird! (ring (7,a),(x,y),dp; minpoly=a2+1; ) 166 172 167 173 // Wechsel in geeigneten Ring & Variablendefinition  168 174 def altring = basering; 169 if (size(parstr(altring))==1) {string mipl=string(minpoly);} 175 int e; 176 int gcd_ok=1; 177 string mipl="0"; 178 if (size(parstr(altring))==1) {mipl=string(minpoly);} 179 // test: char = (p^k,a) (> gcd not implemented) or (p,a) (gcd works)  180 if ((char(basering)!=0) and (charstr(basering)!=string(char(basering)))) { 181 string tststr=charstr(basering); 182 tststr=tststr[1..find(tststr,",")1]; //> "p^k" bzw. "p" 183 gcd_ok=(tststr==string(char(basering))); 184 } 170 185 execute("ring rsqrf = ("+charstr(altring)+"),(x,y),dp;"); 171 if ( size(parstr(altring))==1) { execute "minpoly="+mipl+";"; }186 if ((gcd_ok!=0) && (mipl!="0")) { execute "minpoly="+mipl+";"; } 172 187 poly f=fetch(altring,f); 173 188 poly dif,g,l; 174 int e; 175 // Berechne f/ggT(f,df/dx,df/dy)  176 dif=diff(f,x); 177 if (dif==0) { g=f; } // zur Beschleunigung 178 else { g=gcd(f,dif); } 179 if (g!=1) { // sonst schon sicher, dass f quadratfrei 180 dif=diff(f,y); 181 if (dif!=0) { g=gcd(g,dif); } 182 } 183 if (g!=1) { 184 e=0; 185 if (g==f) { l=1; } // zur Beschleunigung 186 else { 187 module m=syz(ideal(g,f)); 188 if (deg(m[2,1])>0) { 189 "!! The Singular command 'syz' has returned a wrong result !!"; 190 l=1; // Division f/g muss aufgehen 189 if (gcd_ok!=0) { 190 // Berechne f/ggT(f,df/dx,df/dy)  191 dif=diff(f,x); 192 if (dif==0) { g=f; } // zur Beschleunigung 193 else { g=gcd(f,dif); } 194 if (g!=1) { // sonst schon sicher, dass f quadratfrei 195 dif=diff(f,y); 196 if (dif!=0) { g=gcd(g,dif); } 197 } 198 if (g!=1) { 199 e=0; 200 if (g==f) { l=1; } // zur Beschleunigung 201 else { 202 module m=syz(ideal(g,f)); 203 if (deg(m[2,1])>0) { 204 "!! The Singular command 'syz' has returned a wrong result !!"; 205 l=1; // Division f/g muss aufgehen 206 } 207 else { l=m[1,1]; } 191 208 } 192 else { l=m[1,1]; }193 }194 209 // 195 210 // Polynomdivision geht, wenn factory eingebunden ist … … 198 213 // werden, sollte dann also zum Einsatz gebracht werden (Zeitersparnis) 199 214 // 200 } 201 else { e=1; } 215 } 216 else { e=1; } 217 } 218 else { 219 // Berechne syz(f,df/dx) oder syz(f,df/dy)  220 // Achtung: Ist f reduzibel, koennen Faktoren mit Ableitung Null verloren  221 // gehen! Ist aber nicht weiter schlimm, weil char (p^k,a) nur im irred.  222 // Fall vorkommen kann. Wenn f nicht g^p ist, wird auf jeden Fall  223 // ein Faktor gefunden.  224 dif=diff(f,x); 225 if (dif == 0) { 226 dif=diff(f,y); 227 if (dif==0) { e=2; l=1; } // f is of power divisible by char of basefield 228 else { l=syz(ideal(dif,f))[1,1]; // x^p+y^(p1) abgedeckt 229 if (deg(l)==deg(f)) { e=1;} 230 else {e=0;} 231 } 232 } 233 else { l=syz(ideal(dif,f))[1,1]; 234 if (deg(l)==deg(f)) { e=1;} 235 else {e=0;} 236 } 237 } 202 238 // Wechsel in alten Ring und Rueckgabe des Ergebnisses  203 239 setring altring; … … 276 312 if ((leadcoef(f)<16001) or (leadcoef(f)>16001)) {verbrecher=lead(f);} 277 313 leitexp=leadexp(f); 278 if (( ((leitexp[1] % 32003) == 0) and (leitexp[1]<>0)) 314 if (( ((leitexp[1] % 32003) == 0) and (leitexp[1]<>0)) 279 315 or ( ((leitexp[2] % 32003) == 0) and (leitexp[2]<>0)) ) 280 316 {verbrecher=lead(f);} … … 302 338 HamburgerNoether development a posteriori without having to do 303 339 all the previous calculation once again (0 if not needed) 304 DISPLAY: the (non zero) elements of the HNE305 306 NOTE: if the optional parameter n is given, the HNmatrix will have at least307 n rows. Otherwise the number of rows will be chosen minimal, such that340 DISPLAY: The (non zero) elements of the HNE 341 342 NOTE: If the optional parameter n is given, the HNmatrix will have at least 343 n columns. Otherwise the number of columns will be chosen minimal s.t. 308 344 the matrix contains all necessary information (i.e. all lines of the 309 HNE but the last (which is in general infinite) have place).345 HNE but the last (which is in general infinite) appear). 310 346 If n is negative, the algorithm is stopped as soon as possible, i.e. 311 347 the information computed is enough for 'invariants', but the HNmatrix 312 348 may contain undetermined elements, which are marked with the 313 2nd variable .349 2nd variable (of the basering). 314 350 In any case, the optional parameter only affects the calculation of 315 351 the LAST line of the HNE; develop(f) gives already all necessary … … 318 354 faster; a positive value will improve the exactness of the 319 355 parametrization. 356 357 For time critical computations it is recommended to use 358 "ring ...,(x,y),ls" as basering  it increases the algorithm's speed. 320 359 321 360 EXAMPLES: example develop; shows an example … … 341 380 // 342 381 343 if (char (basering)==1) {382 if (charstr(basering)=="real") { 344 383 "The algorithm doesn't work with 'real' as coefficient field."; 345 384 // denn : map from characteristic 1 to 1 not implemented … … 359 398 // Ende der unzulaessigen Ringe; Ringwechsel in einen guenstigen Ring:  360 399 400 int ringwechsel=(varstr(basering)!="x,y") or (ordstr(basering)!="ls(2),C"); 401 361 402 def altring = basering; 362 execute("ring guenstig = ("+charstr(altring)+"),(x,y),ls;"); 403 if (ringwechsel) { 404 string mipl=string(minpoly); 405 execute("ring guenstig = ("+charstr(altring)+"),(x,y),ls;"); 406 if ((char(basering)==0) && (mipl!="0")) { 407 execute "minpoly="+mipl+";"; 408 }} 409 else { def guenstig=basering; } 363 410 export guenstig; 364 411 365 412 // Initialisierungen  366 413 map m=altring,x,y; 367 poly f=m(f);414 if (ringwechsel) { poly f=m(f); } 368 415 if (defined(Protokoll)) 369 416 {"received polynomial: ",f,", where x =",namex,", y =",namey;} … … 388 435 string ringchar=charstr(basering); 389 436 map xytausch = basering,y,x; 390 if ((p!=0) and (ringchar != string(p))) { 437 if ((p!=0) and (ringchar != string(p))) { 391 438 // coefficient field is extension of Z/pZ 392 execute "int n_elements="+ringchar[1,size(ringchar)2]+";"; 439 execute "int n_elements="+ringchar[1,size(ringchar)2]+";"; 393 440 // number of elements of actual ring 394 441 number generat=par(1); // generator of the coefficient field of the ring … … 402 449 intvec nm = getnm(f); 403 450 N = nm[1]; M = nm[2]; //Berechne Schnittpunkte Newtonpolygon mit Achsen 404 if (N == 0) {" The given polynomial is a unit!!"; Abbruch=1; Ausgabe=1;} 451 if (N == 0) 452 {" The given polynomial is a unit as power series!!"; Abbruch=1; Ausgabe=1;} 405 453 else { 406 454 if (N == 1) {"The HNE is x = 0"; Abbruch=1; Ausgabe=2; getauscht=1;} … … 444 492 if (test_sqr != f) { 445 493 "The given polynomial is in fact not squarefree."; 446 "I'll continue with the radical.", 447 "If you want to stop now, press <Ctrl> c"; 494 "I'll continue with the radical."; 448 495 pause; 449 496 f=test_sqr; … … 452 499 } 453 500 else { 454 if ((str=="s") and (testerg==1)) { 501 if ((str=="s") and (testerg==1)) { 455 502 "(*) attention: it could be that the factor is only one in char 32003!"; 456 503 f=polyhinueber(test_sqr); … … 485 532 if (p != 0) 486 533 {"But if the polynomial contains a factor of the form g^"+string(p)+","; 487 "this factor will be lost. If you want to stop now, press <Ctrl> c";} 488 else {"If you want to stop now, press <Ctrl> c";} 534 "this factor will be lost.";} 489 535 pause; 490 536 f=test_sqr; … … 497 543 498 544 if (N==0) { 499 " Sorry. The remaining polynomial is a unit ...";545 " Sorry. The remaining polynomial is a unit in the power series ring..."; 500 546 setring altring;kill guenstig;return(return_error); 501 547 } … … 556 602 delta = koeff(f,(M/ e)*p^l,(N/ e)*p^l*(eps1)) / (1*eps*c); 557 603 558 if ((ringchar != string(p)) and (delta != 0)) { 604 if ((ringchar != string(p)) and (delta != 0)) { 559 605 // coeff. field is not Z/pZ => we`ve to correct delta by taking (p^l)th root 560 606 if (delta == generat) {exponent=1;} … … 639 685 // Ergebnis in den alten Ring transferieren:  640 686 map zurueck=guenstig,maxideal(1)[1],maxideal(1)[2]; 641 matrix a [zeile+1][maxspalte];687 matrix amat[zeile+1][maxspalte]; 642 688 ideal uebergabe; 643 689 for (e=0; e<=zeile; e=e+1) { 644 690 uebergabe=zurueck(a(e)); 645 // n.b.: im alten Ring ist a(i) Ideal, im neuen die Matrix 646 // (aber gleicher Inhalt: die Koeffizienten der HNE) 647 691 if (ncols(uebergabe) > 1) { 648 a [e+1,1..ncols(uebergabe)]=uebergabe;}649 else {a [e+1,1]=uebergabe[1];}692 amat[e+1,1..ncols(uebergabe)]=uebergabe;} 693 else {amat[e+1,1]=uebergabe[1];} 650 694 } 651 f=zurueck(f);695 if (ringwechsel) { f=zurueck(f); } 652 696 } 653 697 654 698 kill guenstig; 655 if (Ausgabe == 0) { return(list(a ,hqs,getauscht,f));}699 if (Ausgabe == 0) { return(list(amat,hqs,getauscht,f));} 656 700 if (Ausgabe == 1) { return(return_error);} // error has occurred 657 if (Ausgabe == 2) { return(list(matrix(0),intvec(1),getauscht,poly(0)));} 658 } // HNE is x=0 or y=0 701 if (Ausgabe == 2) { return(list(matrix(ideal(0,x)),intvec(1),getauscht, 702 poly(0)));} // HNE is x=0 or y=0 703 } 659 704 example 660 705 { "EXAMPLE:"; echo = 2; … … 675 720 // (the term t109 in y may have a wrong coefficient) 676 721 displayHNE(hne); 677 setring exring; kill displayring;678 722 } 679 723 … … 690 734 will be zero. If not, the real parametrisation will be 691 735 two power series; then param will return a truncation of these series. 692 EXAMPLE S: example develop;shows an example693 example param; shows another example736 EXAMPLE: example param; shows an example 737 example developp; shows another example 694 738 695 739 { … … 794 838 and computes some invariants: 795 839 RETURN: a list, if l contains a valid HNE: 796  invariants(l)[1] =intvec(characteristic exponents)840  invariants(l)[1]: intvec (characteristic exponents) 797 841  invariants(1)[2],[3]: 2 x intvec (puiseux pairs, 1st and 2nd components) 798  invariants(l)[4]=int(degree of the conductor) 842  invariants(l)[4]: int (degree of the conductor) 843  invariants(l)[5]: intvec (sequence of multiplicities) 799 844 an empty list, if an error occurred in the procedure develop 800 845 EXAMPLE: example invariants; shows an example … … 809 854 return(ergebnis); 810 855 } 811 intvec beta,s,svorl,ordnung ;812 int genus,zeile,i, k,summe,conductor,ggT;856 intvec beta,s,svorl,ordnung,multips,multseq,mpuiseux,npuiseux; 857 int genus,zeile,i,j,k,summe,conductor,ggT; 813 858 string Ausgabe; 814 859 int nc=ncols(m); int nr=nrows(m); … … 838 883 } 839 884 // Puiseuxpaare  840 intvec mpuiseux,npuiseux;841 885 int produkt=1; 842 886 for (i=1; i<=genus; i++) { … … 854 898 } 855 899 conductor=summe; 900 // Multiplizitaetensequenz:  901 k=1; 902 multips=multiplicities(#); 903 for (i=1; i<size(v); i++) { 904 for (j=1; j<=v[i]; j++) { 905 multseq[k]=multips[i]; 906 k++; 907 }} 908 multseq[k]=1; 856 909 // Rueckgabe  857 ergebnis=beta,mpuiseux,npuiseux,conductor ;910 ergebnis=beta,mpuiseux,npuiseux,conductor,multseq; 858 911 return(ergebnis); 859 912 } … … 866 919 erg[2],erg[3]; // the puiseux pairs in packed form 867 920 erg[4] / 2; // the deltainvariant 921 erg[5]; // the sequence of multiplicities 868 922 // To display the invariants more 'nicely': 869 923 displayInvariants(hne); … … 875 929 develop(f) and reddevelop(f) 876 930 ( list l (matrix m, intvec v, int s[,poly g]) 877 or list of lists in the form l 931 or list of lists in the form l ) 878 932 DISPLAY: invariants of the corresponding branch, resp. of all branches, 879 933 in a better readable form 880 934 RETURN: nothing 881 EXAMPLE: example invariants; shows an example882 { 883 int i ;935 EXAMPLE: example displayInvariants; shows an example 936 { 937 int i,j,k,mul; 884 938 string Ausgabe; 885 939 list ergebnis; 940 // entferne ueberfluessige Daten zur Erhoehung der Rechengeschwindigkeit:  941 #=stripHNE(#); 886 942 // Ausgabe eines Zweiges  887 943 if (typeof(#[1])=="matrix") { 888 944 ergebnis=invariants(#); 889 945 if (size(ergebnis)!=0) { 890 " characteristic exponents :",ergebnis[1];946 " characteristic exponents :",ergebnis[1]; 891 947 if (size(ergebnis[1])>1) { 892 948 for (i=1; i<=size(ergebnis[2]); i++) { … … 894 950 +string(ergebnis[3][i])+")"; 895 951 }} 896 " puiseux pairs :",Ausgabe;897 " the degree of the conductor is",ergebnis[4];898 " the delta invariant is",ergebnis[4]/2;899 " the generators of the semigroup of values are",900 puiseux2generators(ergebnis[2],ergebnis[3]);952 " puiseux pairs :",Ausgabe; 953 " degree of the conductor :",ergebnis[4]; 954 " delta invariant :",ergebnis[4]/2; 955 " generators of semigroup :",puiseux2generators(ergebnis[2],ergebnis[3]); 956 " sequence of multiplicities:",ergebnis[5]; 901 957 }} 902 958 // Ausgabe aller Zweige  903 959 else { 904 for ( intj=1; j<=size(#); j++) {960 for (j=1; j<=size(#); j++) { 905 961 ergebnis=invariants(#[j]); 906 962 "  invariants of branch number",j,": "; 907 " characteristic exponents :",ergebnis[1];963 " characteristic exponents :",ergebnis[1]; 908 964 Ausgabe=""; 909 965 if (size(ergebnis[1])>1) { … … 912 968 +string(ergebnis[3][i])+")"; 913 969 }} 914 " puiseux pairs :",Ausgabe;915 " the degree of the conductor is",ergebnis[4];916 " the delta invariant is",ergebnis[4]/2;917 " the generators of the semigroup of values are",918 puiseux2generators(ergebnis[2],ergebnis[3]);970 " puiseux pairs :",Ausgabe; 971 " degree of the conductor :",ergebnis[4]; 972 " delta invariant :",ergebnis[4]/2; 973 " generators of semigroup :",puiseux2generators(ergebnis[2],ergebnis[3]); 974 " sequence of multiplicities:",ergebnis[5]; 919 975 ""; 920 976 } 977 if (size(#)>1) { 978 "  intersection multiplicities :  ";""; 979 Ausgabe="branch  "; 980 for (j=size(#); j>1; j) { 981 if (size(string(j))==1) { Ausgabe=Ausgabe+" "+string(j)+" "; } 982 else { Ausgabe=Ausgabe+string(j)+" "; } 983 } 984 Ausgabe; 985 Ausgabe="+"; 986 for (j=2; j<size(#); j++) { Ausgabe=Ausgabe+""; } 987 Ausgabe=Ausgabe+""; 988 Ausgabe; 989 } 990 for (j=1; j<size(#); j++) { 991 if (size(string(j))==1) { Ausgabe=" "+string(j)+" "; } 992 else { Ausgabe=" " +string(j)+" "; } 993 for (k=size(#); k>j; k) { 994 mul=intersection(#[j],#[k]); 995 for (i=1; i<=5size(string(mul)); i++) { Ausgabe=Ausgabe+" "; } 996 Ausgabe=Ausgabe+string(mul); 997 if (k>j+1) { Ausgabe=Ausgabe+","; } 998 } 999 Ausgabe; 1000 } 921 1001 } 922 1002 return(); 1003 } 1004 example 1005 { "EXAMPLE:"; echo = 2; 1006 ring exring=0,(x,y),dp; 1007 list hne=develop(y4+2x3y2+x6+x5y); 1008 displayInvariants(hne); 1009 } 1010 /////////////////////////////////////////////////////////////////////////////// 1011 1012 proc multiplicities 1013 USAGE: multiplicities(l) takes the output of develop(f) 1014 (list l (matrix m, intvec v, int s[,poly g])) 1015 RETURN: intvec of the different multiplicities that occur during the succes 1016 sive blowing up of the curve corresponding to f 1017 EXAMPLE: example multiplicities; shows an example 1018 { 1019 matrix m=#[1]; 1020 intvec v=#[2]; 1021 int switch=#[3]; 1022 list ergebnis; 1023 if (switch==1) { 1024 "An error has occurred in develop, so there is no HNE."; 1025 return(intvec(0)); 1026 } 1027 intvec ordnung; 1028 int zeile,k; 1029 int nc=ncols(m); int nr=nrows(m); 1030 ordnung[nr]=1; 1031 // Bestimme den Untergrad der einzelnen Zeilen  1032 for (zeile=nr; zeile>1; zeile) { 1033 if ((size(ideal(m[zeile,1..nc])) > 1) or (zeile==nr)) { // keine Nullzeile 1034 k=1; 1035 while (m[zeile,k]==0) {k++;} 1036 ordnung[zeile1]=k*ordnung[zeile]; 1037 } 1038 else { 1039 ordnung[zeile1]=v[zeile]*ordnung[zeile]+ordnung[zeile+1]; 1040 }} 1041 return(ordnung); 1042 } 1043 example 1044 { "EXAMPLE:"; echo = 2; 1045 ring r=0,(x,y),dp; 1046 multiplicities(develop(x5+y7)); 1047 // The first value is the multiplicity of the curve itself, here it's 5 923 1048 } 924 1049 /////////////////////////////////////////////////////////////////////////////// … … 969 1094 } 970 1095 /////////////////////////////////////////////////////////////////////////////// 971 proc displayHNE 972 USAGE: displayHNE(l) takes the output of develop(f) 973 (list l (matrix m, intvec v, int s[,poly g])) 974 RETURN: an ideal of the following form: 975 _[1]=y+[]*z(0)^1+[]*z(0)^2+...+z(0)^\{\}*z(1) 976 _[2]=x+ []*z(1)^2+...+z(1)^\{\}*z(2) 977 _[3]= []*z(2)^2+...+z(2)^\{\}*z(3) 978 ... .......................... 979 _[r+1]= []*z(r)^2+... 980 where x,y are the indeterminants of the basering. The values of [] are 981 the coefficients of the HamburgerNoethermatrix, the values of \{\} are 1096 1097 proc intersection (list hn1, list hn2) 1098 USAGE: intersection(hne1,hne2); 1099 hne1,hne2 two lists representing a HNE (normally two entries out of 1100 the output of reddevelop), i.e. list(matrix,intvec,int[,poly]) 1101 RETURN: intersection multiplicity of the branches corresponding to hne1 & hne2 1102 (of type int) 1103 EXAMPLE: example intersection; shows an example 1104 { 1105 // `intersect' ist schon reserviert ...  1106 int i,j,s,sum,schnitt,unterschied; 1107 matrix a1=hn1[1]; 1108 matrix a2=hn2[1]; 1109 intvec h1=hn1[2]; 1110 intvec h2=hn2[2]; 1111 intvec n1=multiplicities(hn1); 1112 intvec n2=multiplicities(hn2); 1113 if (hn1[3]!=hn2[3]) { 1114 // die jeweils erste Zeile von hn1,hn2 gehoert zu verschiedenen Parametern  1115 // d.h. beide Kurven schneiden sich transversal  1116 schnitt=n1[1]*n2[1]; // = mult(hn1)*mult(hn2) 1117 } 1118 else { 1119 // die jeweils erste Zeile gehoert zum gleichen Parameter  1120 unterschied=0; 1121 //h1[1],h2[1];size(h1),size(h2); 1122 for (s=1; (h1[s]==h2[s]) && (s<size(h1)) && (s<size(h2)) 1123 && (unterschied==0); s++) { 1124 for (i=1; (a1[s,i]==a2[s,i]) && (i<=h1[s]); i++) {;} 1125 if (i<=h1[s]) { 1126 unterschied=1; 1127 s; // um s++ am Schleifenende wieder auszugleichen 1128 } 1129 } 1130 if (unterschied==0) { 1131 if ((s<size(h1)) && (s<size(h2))) { 1132 for (i=1; (a1[s,i]==a2[s,i]) && (i<=h1[s]) && (i<=h2[s]); i++) {;} 1133 } 1134 else { 1135 // Sonderfall: Unterschied in letzter Zeile suchen  1136 // Beachte: Es koennen undefinierte Stellen auftreten, bei abbrechender HNE 1137 // muss die EndeMarkierung weg, h_[r] ist unendlich, die Matrix muss mit 1138 // Nullen fortgesetzt gedacht werden 1139 // 1140 if (ncols(a1)>ncols(a2)) { j=ncols(a1); } 1141 else { j=ncols(a2); } 1142 unterschied=0; 1143 if ((h1[s]>0) && (s==size(h1))) { 1144 a1[s,h1[s]+1]=0; 1145 if (ncols(a1)<=ncols(a2)) { unterschied=1; } 1146 } 1147 if ((h2[s]>0) && (s==size(h2))) { 1148 a2[s,h2[s]+1]=0; 1149 if (ncols(a2)<=ncols(a1)) { unterschied=1; } 1150 } 1151 if (unterschied==1) { // mind. eine HNE war endlich 1152 matrix ma1[1][j]=a1[s,1..ncols(a1)]; // und bedarf der Fortsetzung 1153 matrix ma2[1][j]=a2[s,1..ncols(a2)]; // mit Nullen 1154 } 1155 else { 1156 if (ncols(a1)>ncols(a2)) { j=ncols(a2); } 1157 else { j=ncols(a1); } 1158 matrix ma1[1][j]=a1[s,1..j]; // Beschr. auf vergleichbaren 1159 matrix ma2[1][j]=a2[s,1..j]; // Teil (der evtl. y's enth.) 1160 } 1161 // print(ma1);print(ma2); 1162 for (i=1; (ma1[1,i]==ma2[1,i]) && (i<j) && (ma1[1,i]!=var(2)); i++) {;} 1163 if (ma1[1,i]==ma2[1,i]) { 1164 "//** The two HNE's are identical!"; 1165 "//** You have either tried to intersect a branch with itself,"; 1166 "//** or the two branches have been developed separately."; 1167 "// In the latter case use `extdevelop' to extend the HNE's until", 1168 "they differ."; 1169 return(1); 1170 } 1171 if ((ma1[1,i]==var(2))  (ma2[1,i]==var(2))) { 1172 "//** The two HNE's are (so far) identical. This is because they", 1173 "have been"; 1174 "//** computed separately. I need more data; use `extdevelop' to", 1175 "extend them,"; 1176 if (ma1[1,i]==var(2)) {"//** at least the first one.";} 1177 else {"//** at least the second one.";} 1178 return(1); 1179 } 1180 } 1181 } 1182 sum=0; 1183 h1[size(h1)]=ncols(a1)+42; // Ersatz fuer h1[r]=infinity 1184 h2[size(h2)]=ncols(a2)+42; 1185 for (j=1; j<s; j++) {sum=sum+h1[j]*n1[j]*n2[j];} 1186 if ((i<=h1[s]) && (i<=h2[s])) { schnitt=sum+i*n1[s]*n2[s]; } 1187 if (i==h2[s]+1) { schnitt=sum+h2[s]*n1[s]*n2[s]+n2[s+1]*n1[s]; } 1188 if (i==h1[s]+1) { schnitt=sum+h1[s]*n2[s]*n1[s]+n1[s+1]*n2[s]; } 1189 // "s:",s1,"i:",i,"S:",sum; 1190 } 1191 return(schnitt); 1192 } 1193 example 1194 { 1195 if (nameof(basering)=="HNEring") { 1196 def rettering=HNEring; 1197 kill HNEring; 1198 } 1199 "EXAMPLE:"; echo = 2; 1200 ring r=0,(x,y),dp; 1201 list hne=reddevelop((x2y3)*(x2+y3)); 1202 intersection(hne[1],hne[2]); 1203 kill HNEring,r; 1204 echo = 0; 1205 if (defined(rettering)) { // wenn aktueller Ring vor Aufruf von example 1206 setring rettering; // HNEring war, muss dieser erst wieder restauriert 1207 def HNEring=rettering; // werden 1208 export HNEring; 1209 } 1210 } 1211 /////////////////////////////////////////////////////////////////////////////// 1212 1213 proc displayHNE(list ldev,list #) 1214 USAGE: displayHNE(ldev,[,n]); ldev=list 1215 (output list of develop(f) or reddevelop(f)), n=int 1216 RETURN:  if only one argument is given, no return value, but 1217 display an ideal HNE of the following form: 1218 HNE[1]=y+[]*z(0)^1+[]*z(0)^2+...+z(0)^<>*z(1) 1219 HNE[2]=x+ []*z(1)^2+...+z(1)^<>*z(2) 1220 HNE[3]= []*z(2)^2+...+z(2)^<>*z(3) 1221 ....... .......................... 1222 HNE[r+1]= []*z(r)^2+[]*z(r)^3+...... 1223 where x,y are the indeterminates of the basering. The values of [] are 1224 the coefficients of the HamburgerNoether matrix, the values of <> are 982 1225 represented in the HNmatrix as 'x' 983 the 1st line ( _[1]) means that y==[]*z(0)^1+... ,984 the 2nd line ( _[2]) means that x==[]*z(1)^1+...1226 the 1st line (HNE[1]) means that y==[]*z(0)^1+... , 1227 the 2nd line (HNE[2]) means that x==[]*z(1)^1+... 985 1228 so you can see which indeterminate corresponds to which line 986 1229 (it's also possible that x corresponds to the 1st line and y to the 2nd) 987 NOTE: to create this ideal, it is necessary to change the ring. displayHNE 988 does this change  the new ring has the name 'displayring'. 989 EXAMPLE: example develop; shows an example 990 { 1230  if a second argument is given, create and export a new ring with 1231 name 'displayring' containing an ideal 'HNE' as described above 1232 1233 If ldev contains the output of reddevelop(f), displayHNE shows the HNE's 1234 of all branches of f in the form described above. 1235 The optional parameter is then ignored. 1236 EXAMPLE: example displayHNE; shows an example 1237 { 1238 if ((typeof(ldev[1])=="list")  (typeof(ldev[1])=="none")) { 1239 for (int i=1; i<=size(ldev); i++) { 1240 "// HamburgerNoether development of branch nr."+string(i)+":"; 1241 displayHNE(ldev[i]);""; 1242 } 1243 return(); 1244 } 991 1245 // Initialisierungen und Ringwechsel  992 matrix m= #[1];993 intvec v= #[2];994 int switch= #[3];1246 matrix m=ldev[1]; 1247 intvec v=ldev[2]; 1248 int switch=ldev[3]; 995 1249 if (switch==1) { 996 1250 "An error has occurred in develop, so there is no HNE."; 997 1251 return(ideal(0)); 1252 } 1253 if (parstr(basering)!="") { 1254 if (charstr(basering)!=string(char(basering))+","+parstr(basering)) { 1255 "Sorry  not implemented for rings of type (p^k,a),..."; 1256 return(ideal(0)); 1257 } 998 1258 } 999 1259 def altring=basering; … … 1001 1261 def displayring=dazu+altring; 1002 1262 setring displayring; 1003 export displayring; 1263 if (size(#) != 0) { 1264 export displayring; 1265 } 1004 1266 map holematrix=altring,0; // mappt nur die Monome vom Grad Null 1005 1267 matrix m=holematrix(m); … … 1011 1273 } 1012 1274 matrix displaymat=m*n; 1013 ideal displayid; 1014 for (i=1; i<nrows(m); i++) { displayid[i]=displaymat[i,i]+z(i)*z(i1)^v[i]; } 1015 displayid[nrows(m)]=displaymat[nrows(m),nrows(m)]; 1275 ideal HNE; 1276 for (i=1; i<nrows(m); i++) { HNE[i]=displaymat[i,i]+z(i)*z(i1)^v[i]; } 1277 HNE[nrows(m)]=displaymat[nrows(m),nrows(m)]; 1278 if (nrows(m)<2) { HNE[2]=z(0); } 1016 1279 if (switch==0) { 1017 displayid[1] = displayid[1]var(size(v)+2);1018 displayid[2] = displayid[2]var(size(v)+1);1280 HNE[1] = HNE[1]var(size(v)+2); 1281 HNE[2] = HNE[2]var(size(v)+1); 1019 1282 } 1020 1283 else { 1021 displayid[1] = displayid[1]var(size(v)+1); 1022 displayid[2] = displayid[2]var(size(v)+2); 1023 } 1024 keepring(displayring); 1025 return(displayid); 1026 } 1027 1028 1284 HNE[1] = HNE[1]var(size(v)+1); 1285 HNE[2] = HNE[2]var(size(v)+2); 1286 } 1287 if (size(#) == 0) { 1288 HNE; 1289 return(); 1290 } 1291 if (size(#) != 0) { 1292 "// basering is now 'displayring' containing ideal 'HNE'"; 1293 keepring(displayring); 1294 export(HNE); 1295 return(HNE); 1296 } 1297 } 1298 example 1299 { "EXAMPLE:"; echo = 2; 1300 ring r=0,(x,y),dp; 1301 poly f=x3+2xy2+y2; 1302 list hn=develop(f); 1303 displayHNE(hn); 1304 } 1029 1305 /////////////////////////////////////////////////////////////////////////////// 1030 1306 // procedures for reducible curves // … … 1082 1358 // finde alle Monome auf der Geraden durch A und C (unterhalb gibt's keine)  1083 1359 hilf=jet(f,A[2]*C[1]A[1]*C[2],intvec(A[2]C[2],C[1]A[1])); 1084 1360 1085 1361 H=leadexp(xytausch(hilf)); 1086 1362 D=H[2],H[1]; … … 1265 1541 } 1266 1542 else { 1267 execute "ring extdguenstig=("+charstr(basering)+"),(x,y),ls;"; 1543 execute "ring extdguenstig=("+charstr(basering)+"),(x,y),ls;"; 1268 1544 } 1269 1545 } … … 1332 1608 } 1333 1609 example 1334 { "EXAMPLE:"; echo = 2; 1610 { 1611 if (nameof(basering)=="HNEring") { 1612 def rettering=HNEring; 1613 kill HNEring; 1614 } 1615 "EXAMPLE:"; echo = 2; 1335 1616 ring exring=0,(x,y),dp; 1336 1617 list hne=reddevelop(x143y2x11y3x10y2x9+3y4x8+y5x7+3y4x6+x5*(y6+y5)3y6x3y7x2+y8); … … 1347 1628 print(extdevelop(develop(xy22y33y4),4)[1]); 1348 1629 print(extdevelop(develop(xy22y33y4),10)[1]); 1630 kill HNEring,exring; 1631 echo = 0; 1632 if (defined(rettering)) { // wenn aktueller Ring vor Aufruf von example 1633 setring rettering; // HNEring war, muss dieser erst wieder restauriert 1634 def HNEring=rettering; // werden 1635 export HNEring; 1636 } 1637 } 1638 /////////////////////////////////////////////////////////////////////////////// 1639 1640 proc stripHNE (list l) 1641 USAGE: stripHNE(l); takes the output both of develop(f) and reddevelop(f) 1642 ( list l (matrix m, intvec v, int s[,poly g]) 1643 or list of lists in the form l ) 1644 RETURN: a list in the same format as l, but all polynomials g are set to zero 1645 NOTE: The purpose of this procedure is to remove huge amounts of data 1646 no longer needed. It is useful, if one or more of the polynomials 1647 in l consumes much memory. It is still possible to compute invariants, 1648 parametrizations etc. with the stripped HNE(s), but it is not possible 1649 to use extdevelop with them. 1650 EXAMPLE: example stripHNE; shows an example 1651 { 1652 list h; 1653 if (typeof(l[1])=="matrix") { l[4]=poly(0); } 1654 else { 1655 for (int i=1; i<=size(l); i++) { 1656 h=l[i]; 1657 h[4]=poly(0); 1658 l[i]=h; 1659 } 1660 } 1661 return(l); 1662 } 1663 example 1664 { "EXAMPLE:"; echo = 2; 1665 ring r=0,(x,y),dp; 1666 list hne=develop(x2+y3+y4); 1667 hne; 1668 stripHNE(hne); 1349 1669 } 1350 1670 /////////////////////////////////////////////////////////////////////////////// … … 1409 1729 delta = koeff(f,(M/ e)*p^l,(N/ e)*p^l*(eps1)) / (1*eps*c); 1410 1730 1411 if ((charstr(basering) != string(p)) and (delta != 0)) { 1731 if ((charstr(basering) != string(p)) and (delta != 0)) { 1412 1732 // coefficient field is not Z/pZ => (p^l)th root is not identity  1413 1733 delta=0; … … 1437 1757 USAGE: reddevelop(f); f poly 1438 1758 RETURN: HamburgerNoether development of f : 1439 A list of lists in the form of develop(f); each entry contains the 1759 A list of lists in the form of develop(f); each entry contains the 1440 1760 data for one of the branches of f. 1441 1761 For more details type 'help develop;' … … 1496 1816 kill HNhelpring, getminpol; 1497 1817 } 1498 poly f=fetch(altring,f); 1499 1818 if (nvars(altring)==2) { poly f=fetch(altring,f); } 1819 else { 1820 map m=altring,x,y; 1821 poly f=m(f); 1822 kill m; 1823 } 1500 1824 } 1501 1825 export HNEring; … … 1513 1837 // Test, ob Einheit oder Null  1514 1838 if (subst(subst(f,x,0),y,0)!=0) { 1515 "The given polynomial is a unit !";1839 "The given polynomial is a unit in the power series ring!"; 1516 1840 keepring HNEring; 1517 1841 return(list()); // there are no HNEs … … 1529 1853 // Fall basering==0,... : Wechsel in Ring mit char >0  1530 1854 // weil squarefree eine Standardbasis berechnen muss (verwendet Syzygien) 1531 //  wenn f in diesem Ring quadratfrei ist, dann erst recht im Ring guenstig1855 //  wenn f in diesem Ring quadratfrei ist, dann erst recht im Ring HNEring 1532 1856 // 1533 1857 int testerg=(polytest(f)==0); … … 1561 1885 } 1562 1886 else { 1563 if ((str=="s") and (testerg==1)) { 1887 if ((str=="s") and (testerg==1)) { 1564 1888 "(*)attention: it could be that the factor is only one in char 32003!"; 1565 1889 f=polyhinueber(test_sqr); … … 1622 1946 //====================== Ende Test auf Quadratfreiheit ======================= 1623 1947 if (subst(subst(f,x,0),y,0)!=0) { 1624 "Sorry. The remaining polynomial is a unit ...";1948 "Sorry. The remaining polynomial is a unit in the power series ring..."; 1625 1949 keepring HNEring; 1626 1950 return(list()); 1627 1951 } 1628 1952 // Test, ob f teilbar durch x oder y  1629 if (subst(f,y,0)==0) { 1953 if (subst(f,y,0)==0) { 1630 1954 f=f/y; NullHNEy=1; } // y=0 is a solution 1631 if (subst(f,x,0)==0) { 1955 if (subst(f,x,0)==0) { 1632 1956 f=f/x; NullHNEx=1; } // x=0 is a solution 1633 1957 … … 1685 2009 } 1686 2010 if (NullHNEy==1) { 1687 Ergebnis=Ergebnis+list(list(matrix( 0),intvec(1),int(0),poly(0)));2011 Ergebnis=Ergebnis+list(list(matrix(ideal(0,x)),intvec(1),int(0),poly(0))); 1688 2012 } 1689 2013 //  Berechne HNE von allen verbliebenen Zweigen:  … … 1711 2035 } 1712 2036 if (NullHNEx==1) { 1713 Ergebnis=Ergebnis+list(list(matrix( 0),intvec(1),int(1),poly(0)));2037 Ergebnis=Ergebnis+list(list(matrix(ideal(0,x)),intvec(1),int(1),poly(0))); 1714 2038 } 1715 2039 // Loesche globale, nicht mehr benoetigte Objekte:  … … 1728 2052 } 1729 2053 example 1730 { 2054 { 1731 2055 if (nameof(basering)=="HNEring") { 1732 2056 def rettering=HNEring; … … 1818 2142 if (N>1) { f = T1_Transform(f,delta,M/ e); } 1819 2143 else { ende=1; } 1820 "a("+string(zeile)+","+string(Q)+") =",delta;2144 if (defined(Protokoll)) {"a("+string(zeile)+","+string(Q)+") =",delta;} 1821 2145 azeilen=set_list(azeilen,intvec(zeile+1,Q),delta); 1822 2146 } … … 1827 2151 // vollziehe Euklid.Alg. nach, um die HNMatrix zu berechnen:  1828 2152 while (R!=0) { 1829 "h("+string(zeile)+") =",Q;2153 if (defined(Protokoll)) { "h("+string(zeile)+") =",Q; } 1830 2154 hqs[zeile+1]=Q; //denn zeile beginnt mit dem Wert 0 1831 2155 // markiere das Zeilenende der HNE:  … … 1836 2160 M=N; N=R; R=M%N; Q=M / N; 1837 2161 } 1838 "a("+string(zeile)+","+string(Q)+") =",delta;2162 if (defined(Protokoll)) {"a("+string(zeile)+","+string(Q)+") =",delta;} 1839 2163 azeilen=set_list(azeilen,intvec(zeile+1,Q),delta); 1840 2164 } … … 1913 2237 if (charstr(basering)=="0,a") { 1914 2238 faktoren,flag=extrafactor(leitf,M,N); // damit funktion. Bsp. Baladi 5 2239 if (flag==0) 2240 { " ** I cannot proceed, will produce some error messages...";} 1915 2241 } 1916 else {flag=0;} 1917 if (flag==0) 2242 else 1918 2243 { 1919 2244 // faktorisiere das charakt. Polynom:  … … 1932 2257 } 1933 2258 else { 1934 1935 teiler,"is not properly factored!"; 1936 1937 2259 " Change of basering necessary!!"; 2260 if (defined(Protokoll)) { teiler,"is not properly factored!"; } 2261 if (needext==0) { poly zerlege=teiler; } 2262 needext=1; 1938 2263 } 1939 2264 } 1940 2265 } // end(for j) 1941 2266 } 1942 else { deltais= delta; eis=e;}2267 else { deltais=ideal(delta); eis=e;} 1943 2268 if (defined(Protokoll)) {"roots of char. poly:";deltais; 1944 2269 "with multiplicities:",eis;} 1945 2270 if (needext==1) { 1946 2271 // fuehre den Ringwechsel aus:  1947 2272 ringischanged=1; 1948 2273 if ((size(parstr(basering))>0) && string(minpoly)=="0") { 1949 " ** We've had bad luck! The HNE cannot completely be calculated!"; 1950 ringischanged=0; break; // weiter mit gefundenen Faktoren 2274 " ** We've had bad luck! The HNE cannot completely be calculated!"; 2275 // HNE in transzendenter Erw. fehlgeschlagen 2276 kill zerlege; 2277 ringischanged=0; break; // weiter mit gefundenen Faktoren 1951 2278 } 1952 2279 if (parstr(basering)=="") { 1953 1954 1955 1956 2280 EXTHNEnumber++; 2281 splitring(zerlege,"EXTHNEring("+string(EXTHNEnumber)+")"); 2282 poly transf=0; 2283 poly transfproc=0; 1957 2284 } 1958 2285 else { 1959 1960 1961 1962 2286 if (defined(translist)) { kill translist; } // Vermeidung einer Warnung 2287 if (numberofRingchanges>1) { // ein Ringwechsel hat nicht gereicht 2288 list translist=splitring(zerlege,"",list(transf,transfproc)); 2289 poly transf=translist[1]; poly transfproc=translist[2]; 1963 2290 } 1964 2291 else { 1965 1966 1967 2292 if (defined(transfproc)) { // in dieser proc geschah schon Ringwechsel 2293 EXTHNEnumber++; 2294 list translist=splitring(zerlege,"EXTHNEring(" 1968 2295 +string(EXTHNEnumber)+")",list(a,transfproc)); 1969 2296 poly transf=translist[1]; 1970 2297 poly transfproc=translist[2]; 1971 1972 1973 1974 2298 } 2299 else { 2300 EXTHNEnumber++; 2301 list translist=splitring(zerlege,"EXTHNEring(" 1975 2302 +string(EXTHNEnumber)+")",a); 1976 1977 1978 2303 poly transf=translist[1]; 2304 poly transfproc=transf; 2305 }} 1979 2306 } 1980 2307 // … … 2028 2355 if (R==0) { 2029 2356 transformiert = T1_Transform(f,number(deltais[j]),M/ e); 2030 "a("+string(zeile)+","+string(Q)+") =",deltais[j]; 2031 if (defined(Protokoll)) {"transformed polynomial: ",transformiert;} 2357 if (defined(Protokoll)) { 2358 "a("+string(zeile)+","+string(Q)+") =",deltais[j]; 2359 "transformed polynomial: ",transformiert; 2360 } 2032 2361 if (subst(transformiert,y,0)==0) { 2033 2362 "finite HNE found"; … … 2040 2369 // aktualisiere Vektor mit den hqs 2041 2370 if (eis[j]>1) { 2042 2043 2371 transformiert=transformiert/y; 2372 if (subst(transformiert,y,0)==0) { 2044 2373 "THE TEST FOR SQUAREFREENESS WAS BAD!! The polynomial was NOT squarefree!!!";} 2045 2374 else { 2046 2375 // Spezialfall (###) eingetreten: Noch weitere Zweige vorhanden  2047 2376 eis[j]=eis[j]1; 2048 2377 } 2049 2378 } 2050 2379 } … … 2071 2400 M1=M;N1=N;R1=R;Q1=M1/ N1; 2072 2401 while (R1!=0) { 2073 "h("+string(zeile+zl2)+") =",Q1;2402 if (defined(Protokoll)) { "h("+string(zeile+zl2)+") =",Q1; } 2074 2403 HNEs=set_list(HNEs,intvec(hnezaehler,1,zeile+zl1),Q1); 2075 2404 HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl,Q1+1),x); … … 2078 2407 // Bereitstellung von Speicherplatz fuer eine neue Zeile:  2079 2408 HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl),ideal(0)); 2080 2409 2081 2410 M1=N1; N1=R1; R1=M1%N1; Q1=M1 / N1; 2082 2411 } 2083 "a("+string(zeile+zl2)+","+string(Q1)+") =",delta; 2412 if (defined(Protokoll)) { 2413 "a("+string(zeile+zl2)+","+string(Q1)+") =",delta; 2414 } 2084 2415 hilfid=ideal(0); // = HNEs[hnezaehler][zeile+zl]; 2085 2416 hilfid[Q1]=delta;hilfid[Q1+1]=x; … … 2158 2489 M1=M;N1=N;R1=R;Q1=M1/ N1; 2159 2490 while (R1!=0) { 2160 "h("+string(zeile+zl2)+") =",Q1;2491 if (defined(Protokoll)) { "h("+string(zeile+zl2)+") =",Q1; } 2161 2492 HNEs=set_list(HNEs,intvec(hnezaehler,1,zeile+zl1),Q1); 2162 2493 HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl,Q1+1),x); … … 2167 2498 M1=N1; N1=R1; R1=M1%N1; Q1=M1 / N1; 2168 2499 } 2169 "a("+string(zeile+zl2)+","+string(Q1)+") =",delta; 2500 if (defined(Protokoll)) { 2501 "a("+string(zeile+zl2)+","+string(Q1)+") =",delta; 2502 } 2170 2503 HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl,Q1),delta); 2171 2504 … … 2265 2598 testpol=0; 2266 2599 } 2267 if (testpol!=0) { "factorize not implemented in char (0,a)!";2268 "could not factorize",testpol; pause; }2269 2600 } 2270 2601 if (a4==625) { … … 2275 2606 { faktoren=list(ideal(4,y+1/25*a3,y1/25*a3),intvec(1,1,1)); 2276 2607 testpol=0;} 2277 if (testpol!=0) {"could not factorize:",charPoly(leitf,M,N); pause;}2278 2608 } 2279 return(faktoren,defined(testpol)); // Test: faktoren==list() geht leider nicht 2609 if (defined(testpol)==0) { poly testpol=1; } 2610 if (testpol!=0) { 2611 "factorize not implemented in char (0,a)!"; 2612 "could not factorize:",charPoly(leitf,M,N); pause; 2613 } 2614 return(faktoren,(testpol==0)); // Test: faktoren==list() geht leider nicht 2280 2615 } 2281 2616 example … … 2290 2625 if (flag!=0) {factors;} 2291 2626 } 2627
Note: See TracChangeset
for help on using the changeset viewer.