Changeset d336d53 in git


Ignore:
Timestamp:
Apr 6, 1998, 6:31:31 PM (25 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
1caa724ecc92dd76617c98c9946796d008178c53
Parents:
eea9d4ad342a3c2ff7ea5d5f1f54b44edae148e2
Message:
small fixes


git-svn-id: file:///usr/local/Singular/svn/trunk@1340 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/classify.lib

    reea9d4 rd336d53  
    1 // $Id: classify.lib,v 1.20 1998-04-03 23:18:15 krueger Exp $
    2 ///////////////////////////////////////////////////////////////////////////////
    3 
     1// $Id: classify.lib,v 1.21 1998-04-06 16:31:31 krueger Exp $
     2///////////////////////////////////////////////////////////////////////////////
     3
     4version  =       "$Id: classify.lib,v 1.21 1998-04-06 16:31:31 krueger Exp $";
     5info="
    46LIBRARY:  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES 
    57
     
    79   equivalence, based on the determinator of singularities by V.I. Arnold.
    810   Author: Kai Krueger, krueger@mathematik.uni-kl.de
    9    last modified: 08.11.1997
     11   last modified: 04.04.1997
    1012
    1113basicinvariants(f);  computes Milnor number, determinacy-bound and corank of f
     
    2527debug_log (lev,[])   print trace and debugging information w.r.t level>@DeBug
    2628           (parameters in square brackets [] are optional)
     29";
    2730
    2831LIB "inout.lib";
     
    120123
    121124///////////////////////////////////////////////////////////////////////////////
     125static
    122126proc Klassifiziere (poly f)
    123127{
     
    190194
    191195///////////////////////////////////////////////////////////////////////////////
     196static
    192197proc Funktion1bis (poly f, list cstn)
    193198{
     
    256261
    257262///////////////////////////////////////////////////////////////////////////////
     263static
    258264proc Funktion3 (poly f, list cstn)
    259265{
     
    286292
    287293///////////////////////////////////////////////////////////////////////////////
     294static
    288295proc Funktion6 (poly f, list cstn)
    289296{ // Arnold's steps 6-12
     
    364371
    365372///////////////////////////////////////////////////////////////////////////////
     373static
    366374proc Funktion13 (poly f, list cstn)
    367375{
     
    401409
    402410///////////////////////////////////////////////////////////////////////////////
     411static
    403412proc Funktion17 (poly f, list cstn)
    404413{ // Analog zu Fumktion 6, Kombination 17-24
     
    467476
    468477///////////////////////////////////////////////////////////////////////////////
     478static
    469479proc Funktion25 (poly f, list cstn)
    470480{ // Analog zu Fumktion 6, Kombination 25-46
     
    575585
    576586///////////////////////////////////////////////////////////////////////////////
     587static
    577588proc Funktion40 (poly f, list cstn, int k)
    578589{
     
    632643
    633644///////////////////////////////////////////////////////////////////////////////
     645static
    634646proc Funktion50 (poly f, list cstn)
    635647{
     
    684696
    685697///////////////////////////////////////////////////////////////////////////////
     698static
    686699proc Funktion58 (poly fin, list cstn)
    687700{
     
    833846
    834847///////////////////////////////////////////////////////////////////////////////
     848static
    835849proc Funktion59 (poly f, list cstn)
    836850{
     
    910924
    911925///////////////////////////////////////////////////////////////////////////////
     926static
    912927proc Funktion66 (poly f, list cstn)
    913928{
     
    939954
    940955///////////////////////////////////////////////////////////////////////////////
     956static
    941957proc Funktion82 (poly f, list cstn)
    942958{
     
    10331049
    10341050///////////////////////////////////////////////////////////////////////////////
     1051static
    10351052proc Isomorphie_s82_z (poly f, poly fk, int p)
    10361053{
     
    10601077
    10611078///////////////////////////////////////////////////////////////////////////////
     1079static
    10621080proc Isomorphie_s82_x (poly f, poly fk, int p)
    10631081{
     
    10881106
    10891107///////////////////////////////////////////////////////////////////////////////
     1108static
    10901109proc Funktion83 (poly f, list cstn)
    10911110{
     
    11741193
    11751194///////////////////////////////////////////////////////////////////////////////
     1195static
    11761196proc Funktion97 (poly f, list cstn)
    11771197{
     
    12901310
    12911311///////////////////////////////////////////////////////////////////////////////
     1312static
    12921313proc Isomorphie_s17 (poly f, poly fk, int k, int ct, list #)
    12931314{
     
    14091430
    14101431///////////////////////////////////////////////////////////////////////////////
     1432static
    14111433proc printresult (int step, poly f, string typ, list cstn, int m)
    14121434{
     
    14351457
    14361458///////////////////////////////////////////////////////////////////////////////
     1459static
    14371460proc Funktion47 (poly f, list cstn)
    14381461{
     
    14401463    int Mu = cstn[2];
    14411464    int K  = cstn[3];
    1442     string s = "The Singularity '";+Show(jet(f, K), corank, K));
     1465    string s = "The Singularity '";+Show(jet(f, K), corank, K);
    14431466    string tp="";
    14441467//    return(printresult(47, f, tp, cstn, -1));
     
    14511474
    14521475///////////////////////////////////////////////////////////////////////////////
     1476static
    14531477proc Funktion91 (poly f, list cstn, int k)
    14541478{
     
    14581482
    14591483///////////////////////////////////////////////////////////////////////////////
     1484static
    14601485proc Funktion92 (poly f, list cstn, int k)
    14611486{
     
    14651490
    14661491///////////////////////////////////////////////////////////////////////////////
     1492static
    14671493proc Funktion93 (poly f, list cstn, int k)
    14681494{
     
    14721498
    14731499///////////////////////////////////////////////////////////////////////////////
     1500static
    14741501proc Funktion94 (poly f, list cstn, int k)
    14751502{
     
    14791506
    14801507///////////////////////////////////////////////////////////////////////////////
     1508static
    14811509proc Funktion95 (poly f, list cstn, int k)
    14821510{
     
    14861514
    14871515///////////////////////////////////////////////////////////////////////////////
     1516static
    14881517proc Funktion96 (poly f, list cstn, int k)
    14891518{
     
    15361565
    15371566///////////////////////////////////////////////////////////////////////////////
     1567static
    15381568proc Coeffs (list #)
    15391569{
     
    15431573
    15441574///////////////////////////////////////////////////////////////////////////////
     1575static
    15451576proc Morse(poly f, int K, int corank, int ShowPhi)
    15461577{
     
    16901721
    16911722///////////////////////////////////////////////////////////////////////////////
     1723static
    16921724proc Coeff(poly f, list #)
    16931725{
     
    17131745
    17141746///////////////////////////////////////////////////////////////////////////////
     1747static
    17151748proc ReOrder(poly f)
    17161749{
     
    18621895
    18631896///////////////////////////////////////////////////////////////////////////////
     1897static
    18641898proc Cubic (poly f)
    18651899{
     
    19061940
    19071941///////////////////////////////////////////////////////////////////////////////
     1942static
    19081943proc parity  (int e)
    19091944USAGE:    parity()
     
    19151950
    19161951///////////////////////////////////////////////////////////////////////////////
     1952static
    19171953proc HKclass (intvec sg)
    19181954{
     
    19351971
    19361972///////////////////////////////////////////////////////////////////////////////
     1973static
    19371974proc HKclass3 (intvec sg, string SG_Typ, int cnt)
    19381975{
     
    19451982
    19461983///////////////////////////////////////////////////////////////////////////////
     1984static
    19471985proc HKclass3_teil_1 (intvec sg, string SG_Typ, int cnt)
    19481986{
     
    19812019
    19822020///////////////////////////////////////////////////////////////////////////////
     2021static
    19832022proc HKclass5 (intvec sg, string SG_Typ, int cnt)
    19842023{
     
    19922031
    19932032///////////////////////////////////////////////////////////////////////////////
     2033static
    19942034proc HKclass5_teil_1 (intvec sg, string SG_Typ, int cnt)
    19952035{
     
    20932133
    20942134///////////////////////////////////////////////////////////////////////////////
     2135static
    20952136proc HKclass5_teil_2 (intvec sg, string SG_Typ, int cnt)
    20962137{
     
    21712212
    21722213///////////////////////////////////////////////////////////////////////////////
     2214static
    21732215proc HKclass7 (intvec sg, string SG_Typ, int cnt)
    21742216{
     
    21812223
    21822224///////////////////////////////////////////////////////////////////////////////
     2225static
    21832226proc HKclass7_teil_1 (intvec sg, string SG_Typ, int cnt)
    21842227{
     
    22922335
    22932336///////////////////////////////////////////////////////////////////////////////
     2337static
    22942338proc Singularitaet (string typ,int k,int r,int s,poly a,poly b,poly c,poly d)
    22952339{
     
    23932437{
    23942438   int len = size(#);
     2439//   int printresult = printlevel - level +1;
     2440//   if(level>1) {
     2441//     dbprint(printresult, "Debug:("+ string(level)+ "): ", #[2..len]);
     2442//   }
     2443//   else { dbprint(printresult, #[1..len]); }
    23952444   if( defined(@DeBug) == 0 ) { init_debug(); }
    23962445   if(@DeBug>=level) {
     
    24442493    }
    24452494  }
     2495  printlevel = @DeBug;
    24462496}
    24472497example
     
    24972547}
    24982548///////////////////////////////////////////////////////////////////////////////
     2549static
    24992550proc Faktorisiere(poly f, poly fk, int pt, int k, intvec RFlg)
    25002551{
     
    25482599
    25492600///////////////////////////////////////////////////////////////////////////////
     2601static
    25502602proc Teile(poly f, poly fk)
    25512603{
     
    25582610
    25592611///////////////////////////////////////////////////////////////////////////////
     2612static
    25602613proc GetRf (poly fi, int n)
    25612614USAGE:    GetRf();
     
    25862639
    25872640///////////////////////////////////////////////////////////////////////////////
     2641static
    25882642proc Show(poly g)
    25892643{
     
    25992653
    26002654///////////////////////////////////////////////////////////////////////////////
     2655static
    26012656proc checkring
    26022657{
     
    26112666
    26122667///////////////////////////////////////////////////////////////////////////////
     2668static
    26132669proc DecodeNormalFormString (string S_in)
    26142670USAGE:    DecodeNormalFormString
     
    28042860EXAMPLE: no example
    28052861{ "   Internal functions for the classification using Arnold's method,";
    2806   "   the function numbers correspond to numbers in Arnold's classifier:";
     2862 "   the function numbers correspond to numbers in Arnold's classifier:";
    28072863 "Klassifiziere(poly f);             determine the type of the singularity f
    28082864  Funktion1bis (poly f, list cstn)
  • Singular/ipassign.cc

    reea9d4 rd336d53  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipassign.cc,v 1.25 1998-04-03 17:38:38 Singular Exp $ */
     4/* $Id: ipassign.cc,v 1.26 1998-04-06 16:27:15 krueger Exp $ */
    55
    66/*
     
    348348  if(res->data!=NULL) piCleanUp((procinfo *)res->data);
    349349  if(a->rtyp==STRING_CMD) {
    350     res->data = (void *)Alloc(sizeof(procinfo));
    351     memset(res->data,0,sizeof(*(res->data)));
     350    res->data = (void *)Alloc0(sizeof(procinfo));
    352351    ((procinfo *)(res->data))->language=LANG_NONE;
    353352    iiInitSingularProcinfo((procinfo *)res->data,"",res->name,0,0);
  • Singular/iplib.cc

    reea9d4 rd336d53  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iplib.cc,v 1.14 1998-04-03 22:46:53 krueger Exp $ */
     4/* $Id: iplib.cc,v 1.15 1998-04-06 16:27:17 krueger Exp $ */
    55/*
    66* ABSTRACT: interpreter: LIB and help
     
    2525#endif /* HAVE_LIBPARSER */
    2626
    27 procinfo *iiInitSingularProcinfo(procinfo *pi, char *libname, char *procname,
    28                                  int line, long pos, BOOLEAN pstatic=FALSE);
    2927char *iiConvName(char *p);
    3028#ifdef HAVE_LIBPARSER
     
    502500  print_init();
    503501#  endif
    504   Warn( "loading %s...", libnamebuf);
     502  if (BVERBOSE(V_LOAD_LIB)) Print( "// ** loading %s...", libnamebuf);
    505503  yylplex(newlib, libnamebuf, &lib_style);
    506504  if(lib_style == OLD_LIBSTYLE)
     
    508506          newlib);
    509507  else {
    510     Warn( "loading %s done, version: %s", newlib, text_buffer);
    511     FreeL(text_buffer);
     508    if (BVERBOSE(V_LOAD_LIB)) Print("done.\n");
    512509  }
    513510  if(yylp_errno) {
  • Singular/libparse.h

    reea9d4 rd336d53  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: libparse.h,v 1.2 1998-04-03 22:46:55 krueger Exp $ */
     6/* $Id: libparse.h,v 1.3 1998-04-06 16:27:19 krueger Exp $ */
    77/*
    88* ABSTRACT: lib parsing
     
    1414procinfo *iiInitSingularProcinfo(procinfov pi, char *libname,
    1515                                 char *procname, int line, long pos,
    16                                  BOOLEAN pstatic = 0);
     16                                 BOOLEAN pstatic = FALSE);
    1717int yylplex(char *libname, char *libfile, lib_style_types *lib_style,
    1818            lp_modes=LOAD_LIB);
  • Singular/libparse.l

    reea9d4 rd336d53  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 /* $Id: libparse.l,v 1.4 1998-04-03 22:46:56 krueger Exp $ */
     5/* $Id: libparse.l,v 1.5 1998-04-06 16:27:20 krueger Exp $ */
    66#include <stdio.h>
    77#include <string.h>
     
    8383#define YYLP_MISS_BR3   12
    8484
     85#ifdef __cplusplus
     86extern "C" {
     87#endif
     88#ifdef macintosh
     89int    fileno(FILE *stream);
     90FILE   *fdopen(int filedes, char *type);
     91long   ftell(FILE *fp);
     92long   tell(int filedes);
     93int    isatty(int filedes);
     94#endif /* macintosh */
     95#ifdef __cplusplus
     96}
     97#endif
     98
    8599#ifdef STANDALONE_PARSER
    86100procinfov pi;
     
    133147  #define YY_DECL int yylex(char *newlib, char *libfile, \
    134148                                 lib_style_types *lib_style, \
    135                                  lp_modes mode = LOAD_LIB)
     149                                 lp_modes mode)
    136150
    137151  #undef YY_INPUT
     
    165179comment        [\/][\/]
    166180dolar          [$]
    167 symbols        [~!@#$%^&*()_+-={}\\\|\[\];:,<.>/\?\' \n\~\`]
     181symbols        [~!@#$%^&*()_+-={}\\\|\[\];:,<.>/\?\' \n\~\`\r]
    168182aletters       ({letter}|{digit}|{symbols}|{dolar}|{escquote})
    169183strings        ({aletters}*)
     
    203217               printf("Version:%s;\n", libnamebuf);
    204218#else
    205                text_buffer = mstrdup(libnamebuf);
     219               //text_buffer = mstrdup(libnamebuf);
     220               print_version(mode, libnamebuf);
    206221#endif
    207222             }
     
    261276<header>({comment}+{tos}+{dolar}+Id:+{string}+[^\n]*)|({comment}+{tos}+{dolar}+Header:+{string}+[^\n]*) {
    262277             make_version(yytext, 0);
    263            }
    264 <header>^{comment}+[^\n]* {
     278             //print_version(mode, "");
    265279#if YYLPDEBUG > 1
    266              printf("+HEAD:%s\n", yytext);
    267 #endif
    268            }
    269 <header>(^#![^\n]*)      {
     280             printf("+(id)HEAD:%s\n", yytext);
     281#endif
     282           }
     283<header>(^{comment}+[^\n]*) {
     284#if YYLPDEBUG > 1
     285             printf("+(cmt)HEAD:%s\n", yytext);
     286#endif
     287           }
     288<header>(^#![^\n]*) {
    270289#if YYLPDEBUG > 1
    271290             printf("-HEAD:%s\n", yytext);
     
    273292           }
    274293<header>^proc\  { yyless(0);
    275              print_version(mode, libfile);
     294             //print_version(mode, libfile);
    276295             BEGIN(INITIAL);
    277296             yymore();
     
    284303
    285304<header>^LIB[ \t]+"\""   { quote++;
    286              print_version(mode, libfile);
     305             //print_version(mode, libfile);
    287306             BEGIN(libcmd);
    288307           }
     
    292311             printf(" HEAD:%s\n", yytext);
    293312#endif
    294              print_version(mode, libfile);
     313             //print_version(mode, libfile);
    295314             BEGIN(help);
    296315           }
    297 <help>^{comment}+[^\n]*  {
     316<help>(^{comment}+[^\n]*)  {
    298317#if YYLPDEBUG > 1
    299318             printf(" HELP:%s\n", yytext);
    300319#endif
    301320             BEGIN(INITIAL); }
    302 <help>^#![^\n]*          {
     321<help>(^#![^\n]*) {
    303322#if YYLPDEBUG > 1
    304323             printf(" HELP:%s\n", yytext);
    305324#endif
    306325             BEGIN(INITIAL);
     326           }
     327<help>(info=\")|(version=\")|(version+{tos}+=\")|(version+{tos}+=+{tos}+\")|(version=+{tos}+\") { yyless(0);
     328             *lib_style = NEW_LIBSTYLE;
     329             BEGIN(INITIAL);
     330             yymore();
    307331           }
    308332<help>^proc\  {
     
    316340           }
    317341
    318 <help>\n   { yylplineno++; }
     342<help>\n { yylplineno++; }
    319343<help>.    {
    320344#if YYLPDEBUG > 1
     
    371395             }
    372396           }
    373 <pdef>\n   { yylplineno++;
    374              if(brace2<=0) {
    375 #if YYLPDEBUG
    376                printf("BEGIN(phead-2){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
    377 #endif
    378                SET_HELP_START(mode, pi, current_pos(0));
    379                BEGIN(phead);
    380              }
    381            }
     397<pdef>\n { yylplineno++;
     398              if(brace2<=0) {
     399#if YYLPDEBUG
     400                printf("BEGIN(phead-2){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
     401#endif
     402                SET_HELP_START(mode, pi, current_pos(0));
     403                BEGIN(phead);
     404              }
     405            }
    382406<pdef>.    {
    383407             if(brace2<=0) {
     
    398422#endif
    399423                         }
    400 <phead>\n                { yylplineno++; }
     424<phead>\n             { yylplineno++; }
    401425<phead>.                 { }
    402426
    403 <pbody>{comment}[^\n]*        { }
     427<pbody>({comment}[^\n]*) { }
    404428<pbody>"\""              { quote++; old_state = YYSTATE;
    405429                           BEGIN(string); /* printf("%s", yytext); */
     
    465489<string>.                { }
    466490
    467 <pexample>\/\/[^\n]*     { }
     491<pexample>(\/\/[^\n]*)  { }
    468492<pexample>"\""           { quote++; old_state = YYSTATE;
    469493                           BEGIN(string); /* printf("%s", yytext); */
     
    534558  offset = ftell(f);
    535559  rc  = fread( buf, 1, max_size, f );
     560#if YYLPDEBUG >2
     561  printf("fread: %d of %d\n", rc, max_size);
     562#endif
     563#ifdef macintosh
     564  char *p = buf, *q;
     565  while( (q = strchr(p, '\r')) != NULL) {
     566    *q = '\n';
     567    p = q;
     568  }
     569#endif
    536570  yylp_buffer_start = buf;
    537571  return rc;
     
    582616    int len = (int)(current_pos(0) - string_start);
    583617    fseek(yylpin, string_start, SEEK_SET);
    584     text_buffer = AllocL(len+1);
     618    text_buffer = (char *)AllocL(len+1);
    585619    fread(text_buffer, len, 1, yylpin);
    586620    fseek(yylpin, current_location, SEEK_SET);
     
    599633#else
    600634  if ( mode == LOAD_LIB ) {
    601     if (BVERBOSE(V_LOAD_LIB))
    602        Warn( "loading %s%s", p, libnamebuf);
     635    if (BVERBOSE(V_LOAD_LIB) && p!=NULL ) Print(" %s...", p);
     636       //Warn( "loading %s%s", p, libnamebuf);
    603637  }
    604638#endif
Note: See TracChangeset for help on using the changeset viewer.