{                               /* --- get code of processing mode */  for ( ; tab->name; tab++)     /* look up name in table */    if (strcmp(tab->name, name) == 0)      return tab->code;         /* return the code of the init. mode */  return -1;                    /* or an error indicator */}  /* code() *//*--------------------------------------------------------------------*/int main (int argc, char *argv[]){                               /* --- main function */  int    i, k = 0, n;           /* loop variables, buffers */  char   *s;                    /* to traverse options */  char   **optarg = NULL;       /* option argument */  #ifdef MATVERSION  char   *fn_in   = NULL;       /* name of input cluster file */  #else  char   *fn_dom  = NULL;       /* name of domain file */  char   *fn_hdr  = NULL;       /* name of table header file */  char   *trgname = NULL;       /* name of optional target attribute */  #endif  char   *fn_pat  = NULL;       /* name of table/pattern file */  char   *fn_out  = NULL;       /* name of output cluster file */  char   *blanks  = NULL;       /* blank  characters */  char   *fldseps = NULL;       /* field  separators */  char   *recseps = NULL;       /* record separators */  char   *ininame = "points";   /* name of initialization mode */  char   *nrmname = "sum1";     /* name of normalization mode */  char   *updname = "altopt";   /* name of parameter update method */  char   *modname = "none";     /* name of parameter update modifier */  int    clscnt   = 2;          /* number of clusters */  int    type     = CLS_CENTER; /* cluster type */  double rfnps[]  = {2, 0};     /* radial function parameters */  int    gauss    = 0;          /* flag for Gaussian function */  int    nrmmode  = 0;          /* normalization mode */  double nrmps[]  = {1, 0};     /* normalization parameters */  double noise    = 0;          /* m.s. degree to noise cluster */  int    owrite   = 0;          /* overwrite parameters with options */  int    irnorm   = 1;          /* flag for input range normalization */  int    inimode  = 0;          /* initialization mode */  int    seed     = (int)time(NULL); /* seed value for random numbers */  double range    = 0;          /* range for random offsets */  double radius   = 1.0;        /* initial cluster size (radius) */  int    method   = 0;          /* parameter update method */  int    epochs   = 1000;       /* number of update epochs */  int    update   = 0;          /* number of patterns between updates */  int    conly    = 0;          /* epochs to update centers only */  int    shuffle  = 1;          /* shuffle pattern set */  double trmchg   = 0;          /* maximum change for termination */  double msexp    = 2.0;        /* membership exponent for adaptation */  double regps[]  = {0,1,1,0,0};/* regularization parameters */  double lrates[] = {0.2,0.2,0.2}; /* learning rates */  double decays[] = {-.2,-.2,-.2}; /* learning rate decay params. */  double moment   = 0;          /* momentum term coefficient */  double growth   = 1.2;        /* growth factor for learning rate */  double shrink   = 0.5;        /* shrink factor for learning rate */  double minchg   = 0;          /* minimal change (resilient update) */  double maxchg   = 2;          /* maximal change (resilient update) */  int    maxlen   = 0;          /* maximal output line length */  int    dmode    = CLS_TITLE;  /* description mode */  double chg, t;                /* maximal change of a center coord. */  #ifdef MATVERSION  int    exclude  = 0;          /* number of target fields to exclude */  int    attcnt   = 0;          /* number of attributes */  int    patcnt   = 0;          /* number of patterns */  MATRIX *submat;               /* submatrix for usable columns */  TFSERR *err;                  /* error information */  #else  int    flags    = AS_NOXATT|AS_NOUNKS;  /* table file read flags */  TUPLE  *tpl;                  /* to traverse the patterns */  #endif  prgname = argv[0];            /* get program name for error msgs. */  /* --- print startup/usage message --- */  if (argc > 1) {               /* if arguments are given */    fprintf(stderr, "%s - %s\n", argv[0], DESCRIPTION);    fprintf(stderr, VERSION); } /* print a startup message */  else {                        /* if no argument given */    #ifdef MATVERSION    printf("usage: %s [options] patfile outfile [infile]\n", argv[0]);    #else    printf("usage: %s [options] domfile "                    "[-d|-h hdrfile] tabfile outfile\n", argv[0]);    #endif    printf("%s\n", DESCRIPTION);    printf("%s\n", VERSION);    printf("-!       print a list of init. and norm. modes "                    "and update methods\n");    printf("-c#      number of clusters               "                    "(default: %d)\n", clscnt);    printf("-Z       adaptable size                   "                    "(default: fixed size)\n");    printf("-v       adaptable variances              "                    "(default: unit variances)\n");    printf("-V       adaptable covariances            "                    "(default: unit matrix)\n");    printf("-w       adaptable weights/prior probs.   "                    "(default: equal weights)\n");    printf("-N       normalize to unit integral       "                    "(default: no normalization)\n");    printf("-G       Gaussian radial function         "                    "(default: Cauchy function)\n");    printf("-p#:#    radial function parameters       "                    "(default: %g:%g)\n", rfnps[0], rfnps[1]);    printf("-y#      membership to noise cluster      "                    "(default: %g)\n", noise);    printf("-J#:#    membership transform parameters  "                    "(default: %g:%g)\n", nrmps[0], nrmps[1]);    printf("-j#      membership normalization mode    "                    "(default: %s)\n", nrmname);    printf("-O       overwrite with option values     "                    "(default: parameters read)\n");    #ifdef MATVERSION    printf("-X#      number of fields to exclude      "                    "(default: use all fields)\n");    #else    printf("-X#      exclude a target attribute       "                    "(default: use all attributes)\n");    #endif    printf("-q       do not normalize input ranges    "                    "(default: mean=0, var=1)\n");    printf("-S#      seed for random numbers          "                    "(default: time)\n");    printf("-i#      initialization mode              "                    "(default: %s)\n", ininame);    printf("-o#      random offset range              "                    "(default: %g)\n", range);    printf("-I#      initial cluster size (radius)    "                    "(default: %g)\n", radius);    printf("-a#      parameter update method          "                    "(default: %s)\n", updname);    printf("-A#      parameter update modifier        "                    "(default: %s)\n", modname);    printf("-0       fix centers at origin            "                    "(default: free centers)\n");    printf("-U       normalize centers to unit length "                    "(default: no normalization)\n");    printf("-s       do not shuffle patterns          "                    "(default: once per epoch)\n");    printf("-e#      maximum number of update epochs  "                    "(default: %d)\n", epochs);    printf("-k#      patterns between two updates     "                    "(default: %d)\n", update);    printf("-C#      epochs to update centers only    "                    "(default: %d)\n", conly);    printf("-T#      maximum change for termination   "                    "(default: %g)\n", trmchg);    printf("-x#      exponent for pattern weight      "                    "(default: %g)\n", msexp);    printf("-H#      shape regularization parameter   "                    "(default: %g)\n", regps[3]);    printf("-R#:#:#  size  regularization parameters  "                    "(default: %g:%g:%g)\n",                     regps[0], regps[1], regps[2]);    printf("-W#      weight regularization parameter  "                    "(default: %g)\n", regps[4]);    printf("-t#:#:#  learning rates                   "                    "(default: %g:%g:%g)\n",                     lrates[0], lrates[1], lrates[2]);    printf("-D#:#:#  learning rates decay parameters  "                    "(default: %g:%g:%g)\n",                     decays[0], decays[1], decays[2]);    printf("-m#      momentum coefficient             "                    "(default: %g)\n", moment);    printf("-g#:#    growth and shrink factor         "                    "(default: %g:%g)\n", growth, shrink);    printf("-z#:#    range of change/learning rate    "                    "(default: %g:%g)\n", minchg, maxchg);    printf("-l#      output line length               "                    "(default: no limit)\n");    printf("-b/f/r#  blank characters, field and record separators\n"           "         (default: \" \\t\\r\", \" \\t\", \"\\n\")\n");    #ifdef MATVERSION    printf("patfile  pattern file to read (no header, only numbers)\n");    printf("outfile  file to write induced cluster set to\n");    printf("infile   file to read initial cluster set from "                    "(optional)\n");    #else    printf("-n       number of tuple occurrences in last field\n");    printf("domfile  file containing domain descriptions\n"           "         (and optionally an initial cluster set)\n");    printf("-d       use default header "                    "(field names = field numbers)\n");    printf("-h       read table header (field names) from hdrfile\n");    printf("hdrfile  file containing table header (field names)\n");    printf("tabfile  table file to read "                    "(field names in first record)\n");    printf("outfile  file to write induced cluster set to\n");    #endif    return 0;                   /* print a usage message */  }                             /* and abort the program */  /* --- evaluate arguments --- */  for (i = 1; i < argc; i++) {  /* traverse arguments */    s = argv[i];                /* get option argument */    if (optarg) { *optarg = s; optarg = NULL; continue; }    if ((*s == '-') && *++s) {  /* -- if argument is an option */      while (1) {               /* traverse characters */        switch (*s++) {         /* evaluate option */          case '!': help();                              break;          case 'c': clscnt  = (int)strtol(s, &s, 0);     break;          case 'Z': type   |= CLS_SIZE;                  break;          case 'v': type   |= CLS_VARS;                  break;          case 'V': type   |= CLS_COVARS;                break;          case 'w': type   |= CLS_WEIGHT;                break;          case 'N': type   |= CLS_NORM;                  break;          case 'G': gauss   = 1;                         break;          case 'p': getdblvec(s, &s, 2, rfnps);          break;          case 'y': noise   =      strtod(s, &s);        break;          case 'J': getdblvec(s, &s, 2, nrmps);          break;          case 'j': optarg  = &nrmname;                  break;          case 'O': owrite  = 1;                         break;          #ifdef MATVERSION          case 'X': exclude = (int)strtol(s, &s, 0);     break;          #else          case 'X': optarg  = &trgname;                  break;          #endif          case 'q': irnorm  = 0;                         break;          case 'S': seed    = (int)strtol(s, &s, 0);     break;          case 'i': optarg  = &ininame;                  break;          case 'o': range   =      strtod(s, &s);        break;          case 'I': radius  =      strtod(s, &s);        break;          case 'a': optarg  = &updname;                  break;          case 'A': optarg  = &modname;                  break;          case '0': method |= CLS_ORIGIN;                break;          case 'U': method |= CLS_UNIT;                  break;          case 's': shuffle = 0;                         break;          case 'e': epochs  = (int)strtol(s, &s, 0);     break;          case 'k': update  = (int)strtol(s, &s, 0);     break;          case 'C': conly   = (int)strtol(s, &s, 0);     break;          case 'T': trmchg  =      strtod(s, &s);        break;          case 'x': msexp   =      strtod(s, &s);        break;          case 'H': getdbls(s, &s, 1, regps+3);          break;          case 'R': getdblvec(s, &s, 3, regps);          break;          case 'W': getdbls(s, &s, 1, regps+4);          break;          case 't': getdblvec(s, &s, 3, lrates);         break;          case 'D': getdblvec(s, &s, 3, decays);         break;          case 'm': moment  =      strtod(s, &s);        break;          case 'g': getdbls(s, &s, 2, &growth, &shrink); break;          case 'z': getdbls(s, &s, 2, &minchg, &maxchg); break;          case 'l': maxlen  = (int)strtol(s, &s, 0);     break;          case 'b': optarg  = &blanks;                   break;          case 'f': optarg  = &fldseps;                  break;          case 'r': optarg  = &recseps;                  break;          #ifndef MATVERSION          case 'n': flags  |= AS_WEIGHT;                 break;          case 'd': flags  |= AS_DFLT;                   break;          case 'h': optarg  = &fn_hdr;                   break;          #endif          default : error(E_OPTION, *--s);               break;        }                       /* set option variables */        if (!*s) break;         /* if at end of string, abort loop */        if (optarg) { *optarg = s; optarg = NULL; break; }      } }                       /* get option argument */    else {                      /* -- if argument is no option */      switch (k++) {            /* evaluate non-option */        #ifdef MATVERSION        case  0: fn_pat = s;      break;        case  1: fn_out = s;      break;        case  2: fn_in  = s;      break;        #else        case  0: fn_dom = s;      break;        case  1: fn_pat = s;      break;        case  2: fn_out = s;      break;        #endif        default: error(E_ARGCNT); break;      }                         /* note filenames */    }  }  if (optarg) error(E_OPTARG);  /* check the option argument */