home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / misc / sci / units / source / units.c < prev   
Encoding:
C/C++ Source or Header  |  1994-08-01  |  13.9 KB  |  616 lines
  1. /* 
  2.    units.c   Copyright (c) 1993 by Adrian Mariano
  3.  
  4.    This program can be freely distributed as long as no money is
  5.    charged for it. 
  6. */
  7.  
  8.  
  9. #include<stdio.h>
  10. #include<string.h>
  11. #include<stdlib.h>
  12. #include <ctype.h>
  13.  
  14. #if defined(__SASC_650) && defined(_AMIGA)
  15. #include <dos.h>
  16. char __stdiowin[] = "CON:0/0/640/200/Units";
  17. #endif
  18.  
  19. #define VERSION "$VER: units 1.0 (14.7.93)"
  20.  
  21. #ifndef UNITSFILE
  22. #define UNITSFILE "units.lib"
  23. #endif
  24.  
  25. #define MAXUNITS 1000
  26. #define MAXPREFIXES 50
  27.  
  28. #define MAXSUBUNITS 500
  29.  
  30. #define PRIMITIVECHAR '!'
  31.  
  32. /* prototypes as desired by SAS/C 6.51 for Amiga (Ron Charlton) */
  33. #include "units_protos.h"
  34. #include "getopt_protos.h"
  35.  
  36. char *powerstring="^";
  37.  
  38. struct {
  39.    char *uname;
  40.    char *uval;
  41. } unittable[MAXUNITS];
  42.  
  43. struct unittype {
  44.    char *numerator[MAXSUBUNITS];
  45.    char *denominator[MAXSUBUNITS];
  46.    double factor;
  47. };
  48.  
  49. struct {
  50.    char *prefixname;
  51.    char *prefixval;
  52. } prefixtable[MAXPREFIXES];
  53.  
  54.  
  55. char *NULLUNIT="";
  56.  
  57. int unitcount;
  58. int prefixcount;
  59.  
  60.  
  61. char *dupstr(char *str)
  62. {
  63.   char *ret;
  64.   ret=malloc(strlen(str)+1);
  65.   if (!ret) {
  66.     fprintf(stderr,"Memory allocation error\n");
  67.     exit(3);
  68.   }
  69.   strcpy(ret,str);
  70.   return(ret);
  71. } 
  72.  
  73.  
  74. void readerror(int linenum)
  75. {
  76.   fprintf(stderr,"Error in units file '%s' line %d\n",UNITSFILE,linenum);
  77. }
  78.  
  79.  
  80. void readunits(char *userfile)
  81. {
  82.   FILE *unitfile;
  83.   char line[80],*lineptr;
  84.   int len,linenum,i;
  85.  
  86.   unitcount=0;
  87.   linenum=0;
  88.  
  89.   if (userfile){
  90.     unitfile=fopen(userfile,"rt");
  91.     if (!unitfile) {
  92.       fprintf(stderr,"Unable to open units file '%s'\n",userfile);
  93.       exit(1);
  94.     }
  95.   } else {
  96.     unitfile=fopen(UNITSFILE,"rt");
  97.     if (!unitfile) { 
  98.       char *direc,*env;
  99.       char filename[1000];
  100.       char separator[2];
  101.       env=getenv("PATH");
  102.       if (env){
  103.         if (strchr(env,';')) strcpy(separator,";");
  104.         else strcpy(separator,":");
  105.         direc=strtok(env,separator);
  106.         while(direc){
  107.           strcpy(filename,"");
  108.           strncat(filename,direc,999);
  109.           strncat(filename,"/",999-strlen(filename));
  110.           strncat(filename,UNITSFILE,999-strlen(filename));
  111.           unitfile=fopen(filename,"rt");
  112.           if (unitfile) break;
  113.           direc=strtok(NULL,separator);
  114.         }
  115.       }
  116.       if (!unitfile){
  117.         fprintf(stderr,"Can't find units file '%s'\n",UNITSFILE);
  118.         exit(1);
  119.       }
  120.     }
  121.   }
  122.   while (!feof(unitfile)){
  123.     if (!fgets(line,79,unitfile)) break;
  124.     linenum++;
  125.     lineptr=line;
  126.     if (*lineptr=='/') continue;
  127.     lineptr+=strspn(lineptr," \n\t");
  128.     len = strcspn(lineptr, " \n\t");
  129.     lineptr[len]=0;
  130.     if (!strlen(lineptr)) continue;
  131.     if (lineptr[strlen(lineptr)-1]=='-'){   /* it's a prefix */
  132.       if (prefixcount==MAXPREFIXES) {
  133.         fprintf(stderr,"Memory for prefixes exceeded in line %d\n",linenum);
  134.         continue;
  135.       }
  136.       lineptr[strlen(lineptr)-1]=0;
  137.       prefixtable[prefixcount].prefixname=dupstr(lineptr);
  138.       for(i=0;i<prefixcount;i++) 
  139.         if (!strcmp(prefixtable[i].prefixname,lineptr)){
  140.         fprintf(stderr,"Redefinition of prefix '%s' on line %d ignored\n",
  141.             lineptr,linenum);
  142.     continue;
  143.       }
  144.       lineptr+=len+1;
  145.       if (!strlen(lineptr)) { readerror(linenum); continue;}
  146.       lineptr+=strspn(lineptr," \n\t");
  147.       len = strcspn(lineptr, "\n\t");
  148.       lineptr[len]=0;
  149.       prefixtable[prefixcount++].prefixval=dupstr(lineptr);
  150.     } else {  /* it's not a prefix */
  151.       if (unitcount==MAXUNITS) {
  152.         fprintf(stderr,"Memory for units exceeded in line %d\n",linenum);
  153.         continue;
  154.       }
  155.       unittable[unitcount].uname=dupstr(lineptr);
  156.       for(i=0;i<unitcount;i++) if (!strcmp(unittable[i].uname,lineptr)){
  157.         fprintf(stderr,"Redefinition of unit '%s' on line %d ignored\n",
  158.             lineptr,linenum);
  159.     continue;
  160.       }
  161.       lineptr+=len+1;
  162.       lineptr+=strspn(lineptr," \n\t");
  163.       if (!strlen(lineptr)) { readerror(linenum); continue;}
  164.       len = strcspn(lineptr, "\n\t");
  165.       lineptr[len]=0;
  166.       unittable[unitcount++].uval=dupstr(lineptr);
  167.     }
  168.   }
  169.   fclose(unitfile);
  170. }
  171.  
  172. void initializeunit(struct unittype *theunit)
  173. {
  174.   theunit->factor=1.0;
  175.   theunit->numerator[0]=theunit->denominator[0]=NULL;
  176. }
  177.  
  178.  
  179. int addsubunit(char *product[], char *toadd)
  180. {
  181.   char **ptr;
  182.  
  183.   for(ptr=product;*ptr && *ptr!=NULLUNIT;ptr++);
  184.   if (ptr>=product+MAXSUBUNITS){
  185.     fprintf(stderr,"Memory overflow in unit reduction\n");
  186.     return 1;
  187.   }
  188.   if (!*ptr) *(ptr+1)=0;
  189.   *ptr=dupstr(toadd);
  190.   return 0;
  191. }
  192.  
  193.  
  194. void showunit(struct unittype *theunit)
  195. {
  196.   char **ptr;
  197.   int printedslash;
  198.   int counter=1;
  199.  
  200.   printf("\t%.8g",theunit->factor);
  201.   for(ptr=theunit->numerator;*ptr;ptr++){
  202.     if (ptr>theunit->numerator && **ptr &&
  203.        !strcmp(*ptr,*(ptr-1))) counter++;
  204.       else {
  205.         if (counter>1) printf("%s%d",powerstring,counter);
  206.         if (**ptr) printf(" %s",*ptr);
  207.     counter=1;
  208.       }
  209.   }
  210.   if (counter>1) printf("%s%d",powerstring,counter);
  211.   counter=1;
  212.   printedslash=0;
  213.   for(ptr=theunit->denominator;*ptr;ptr++){
  214.     if (ptr>theunit->denominator && **ptr && 
  215.          !strcmp(*ptr,*(ptr-1))) counter++;
  216.       else {
  217.         if (counter>1) printf("%s%d",powerstring,counter);
  218.         if (**ptr) { 
  219.       if (!printedslash) printf(" /");
  220.       printedslash=1;
  221.           printf(" %s",*ptr);
  222.     }
  223.     counter=1;
  224.       }
  225.   }
  226.   if (counter>1) printf("%s%d",powerstring,counter);
  227.   printf("\n");
  228. }
  229.  
  230.  
  231. void zeroerror()
  232. {
  233.    fprintf(stderr,"Unit reduces to zero\n");
  234. }   
  235.  
  236. /* 
  237.    Adds the specified string to the unit. 
  238.    Flip is 0 for adding normally, 1 for adding reciprocal.
  239.  
  240.    Returns 0 for successful addition, nonzero on error.
  241. */
  242.  
  243. int addunit(struct unittype *theunit,char *toadd,int flip)
  244. {
  245.   char *scratch,*savescr;
  246.   char *item;
  247.   char *divider,*slash;
  248.   int doingtop;
  249.  
  250.   savescr=scratch=dupstr(toadd);
  251.   for(slash=scratch+1;*slash;slash++) 
  252.     if (*slash=='-' && 
  253.       (tolower(*(slash-1))!='e' || !strchr(".0123456789",*(slash+1))))
  254.       *slash=' ';
  255.   slash=strchr(scratch,'/');
  256.   if (slash) *slash=0;
  257.   doingtop=1;
  258.   do{
  259.   item=strtok(scratch," *\t\n/");
  260.   while(item){
  261.     if (strchr("0123456789.",*item)){  /* item is a number */
  262.       double num;
  263.  
  264.       divider=strchr(item,'|');
  265.       if (divider){
  266.     *divider=0;
  267.     num=atof(item);
  268.     if (!num) {
  269.           zeroerror();
  270.           return 1;
  271.         }
  272.     if (doingtop^flip) theunit->factor *= num;
  273.          else  theunit->factor /=num;
  274.     num=atof(divider+1);
  275.     if (!num)  {
  276.           zeroerror();
  277.           return 1;
  278.         }
  279.     if (doingtop^flip) theunit->factor /= num;
  280.      else theunit->factor *= num;
  281.       } else {
  282.     num=atof(item);
  283.     if (!num)  {
  284.           zeroerror();
  285.           return 1;
  286.         }
  287.     if (doingtop^flip) theunit->factor *= num;
  288.     else theunit->factor /= num;
  289.  
  290.       }
  291.     } else {                         /* item is not a number */
  292.       int repeat=1;
  293.       if (strchr("23456789",item[strlen(item)-1])){
  294.     repeat=item[strlen(item)-1]-'0';
  295.     item[strlen(item)-1]=0;
  296.       }
  297.       for(;repeat;repeat--)
  298.     if (addsubunit(doingtop^flip?theunit->numerator:theunit->denominator,item))
  299.   return 1;
  300.     }
  301.     item=strtok(NULL," *\t/\n");
  302.   }
  303.   doingtop--;
  304.   if (slash){
  305.     scratch=slash+1;
  306.   } else doingtop--;
  307.   }while (doingtop>=0 );
  308.   free(savescr);
  309.   return 0;
  310. }
  311.  
  312.  
  313. int compare(const void *item1, const void *item2)
  314. {
  315.   return strcmp(*(char **) item1, * (char **) item2);
  316. }
  317.  
  318.  
  319. void sortunit(struct unittype *theunit)
  320. {
  321.   char **ptr;
  322.   int count;
  323.  
  324.   for(count=0,ptr=theunit->numerator;*ptr;ptr++,count++);
  325.   qsort(theunit->numerator, count, sizeof(char *), compare);
  326.   for(count=0,ptr=theunit->denominator;*ptr;ptr++,count++);
  327.   qsort(theunit->denominator, count, sizeof(char *), compare);
  328. }
  329.  
  330.  
  331. void cancelunit(struct unittype *theunit)
  332. {
  333.   char **den,**num;
  334.   int comp;
  335.  
  336.   den=theunit->denominator;
  337.   num=theunit->numerator;
  338.  
  339.   while(*num && *den){
  340.     comp=strcmp(*den,*num);
  341.     if (!comp) {
  342. /*      if (*den!=NULLUNIT) free(*den);
  343.       if (*num!=NULLUNIT) free(*num);*/
  344.       *den++=NULLUNIT;
  345.       *num++=NULLUNIT;
  346.     }
  347.     else if (comp<0) den++;
  348.     else num++;
  349.   }
  350. }
  351.  
  352.  
  353.  
  354.  
  355. /*
  356.    Looks up the definition for the specified unit.  
  357.    Returns a pointer to the definition or a null pointer
  358.    if the specified unit does not appear in the units table.
  359. */
  360.  
  361. static char buffer[100];  /* buffer for lookupunit answers with prefixes */
  362.  
  363. char *lookupunit(char *unit)
  364. {
  365.   int i;
  366.   char *copy;
  367.  
  368.   for(i=0;i<unitcount;i++){
  369.     if (!strcmp(unittable[i].uname,unit)) return unittable[i].uval;
  370.   }
  371.  
  372.   if (unit[strlen(unit)-1]=='^') {
  373.     copy=dupstr(unit);
  374.     copy[strlen(copy)-1]=0;
  375.     for(i=0;i<unitcount;i++){
  376.       if (!strcmp(unittable[i].uname,copy)) {
  377.         strcpy(buffer,copy);
  378.         free(copy);
  379.         return buffer;
  380.       }
  381.     } 
  382.     free(copy);
  383.   }
  384.   if (unit[strlen(unit)-1]=='s') {
  385.     copy=dupstr(unit);
  386.     copy[strlen(copy)-1]=0;
  387.     for(i=0;i<unitcount;i++){
  388.       if (!strcmp(unittable[i].uname,copy)) {
  389.         strcpy(buffer,copy);
  390.         free(copy);
  391.         return buffer;
  392.       }
  393.     }
  394.     if (copy[strlen(copy)-1]=='e') {
  395.       copy[strlen(copy)-1]=0;
  396.       for(i=0;i<unitcount;i++){
  397.         if (!strcmp(unittable[i].uname,copy)){
  398.           strcpy(buffer,copy);
  399.           free(copy);
  400.           return buffer;
  401.         }
  402.       }
  403.     }
  404.     free(copy);
  405.   }
  406.   for(i=0;i<prefixcount;i++){
  407.     if (!strncmp(prefixtable[i].prefixname,unit,
  408.         strlen(prefixtable[i].prefixname))) {
  409.       unit += strlen(prefixtable[i].prefixname);
  410.       if (!strlen(unit) || lookupunit(unit)){
  411.         strcpy(buffer,prefixtable[i].prefixval);
  412.         strcat(buffer," ");
  413.         strcat(buffer,unit);
  414.         return buffer;
  415.       }
  416.     }
  417.   }
  418.   return 0;
  419. }
  420.  
  421.  
  422.  
  423. /*
  424.    reduces a product of symbolic units to primitive units. 
  425.    The three low bits are used to return flags:
  426.  
  427.      bit 0 (1) set on if reductions were performed without error.
  428.      bit 1 (2) set on if no reductions are performed.
  429.      bit 2 (4) set on if an unknown unit is discovered.
  430. */
  431.  
  432.  
  433. #define ERROR 4
  434.  
  435. int reduceproduct(struct unittype *theunit, int flip)
  436. {
  437.  
  438.   char *toadd;
  439.   char **product;
  440.   int didsomething=2;
  441.  
  442.   if (flip) product=theunit->denominator;
  443.   else product=theunit->numerator;
  444.  
  445.   for(;*product;product++){
  446.     
  447.     for(;;){
  448.       if (!strlen(*product)) break;
  449.       toadd=lookupunit(*product);
  450.       if (!toadd) { 
  451.         printf("unknown unit '%s'\n",*product);
  452.         return ERROR;
  453.       }
  454.       if (strchr(toadd,PRIMITIVECHAR)) break;
  455.       didsomething=1;
  456.       if (*product!=NULLUNIT) {
  457.         free (*product);
  458.         *product=NULLUNIT;
  459.       }
  460.       if (addunit(theunit, toadd, flip)) return ERROR;
  461.     }
  462.   }
  463.   return didsomething;
  464. }
  465.  
  466.  
  467. /* 
  468.    Reduces numerator and denominator of the specified unit.
  469.    Returns 0 on success, or 1 on unknown unit error.
  470. */
  471.  
  472. int reduceunit(struct unittype *theunit)
  473. {
  474.   int ret;
  475.   ret=1;
  476.   while(ret & 1){
  477.     ret = reduceproduct(theunit,0) | reduceproduct(theunit,1);
  478.     if (ret & 4) return 1;
  479.   }
  480.   return 0;
  481. }
  482.  
  483.  
  484. int compareproducts(char **one,char **two)
  485. {
  486.   while(*one || *two){
  487.     if (!*one && *two!=NULLUNIT) return 1;
  488.     if (!*two && *one!=NULLUNIT) return 1;
  489.     if (*one==NULLUNIT) one++;
  490.     else if (*two==NULLUNIT) two++;
  491.     else if (strcmp(*one,*two)) return 1;
  492.     else one++,two++;
  493.   }
  494.   return 0;
  495. }
  496.  
  497.  
  498. /* Return zero if units are compatible, nonzero otherwise */
  499.  
  500. int compareunits(struct unittype *first, struct unittype *second)
  501. {
  502.   return 
  503.     compareproducts(first->numerator,second->numerator) ||
  504.     compareproducts(first->denominator,second->denominator);
  505. }
  506.  
  507.  
  508. int completereduce(struct unittype *unit)
  509. {
  510.   if (reduceunit(unit)) return 1;
  511.   sortunit(unit);
  512.   cancelunit(unit);
  513.   return 0;
  514. }
  515.  
  516.  
  517. void showanswer(struct unittype *have, struct unittype *want)
  518. {
  519.   if (compareunits(have,want)) {
  520.     printf("conformability error\n");
  521.     showunit(have);
  522.     showunit(want);
  523.   }
  524.   else printf("\t* %.8g\n\t/ %.8g\n",have->factor/want->factor,
  525.                            want->factor/have->factor);
  526. }
  527.  
  528.  
  529. void usage()
  530. {
  531.   fprintf(stderr,"\nunits [-f unitsfile] [-q] [-v] [from-unit to-unit]\n");
  532.   fprintf(stderr,"\n    -f specify units file\n");
  533.   fprintf(stderr,"    -q supress prompting (quiet)\n");
  534.   fprintf(stderr,"    -v print version number\n");
  535.   exit(3);
  536. }
  537.  
  538.  
  539. void main(int argc, char **argv){
  540.  
  541.   struct unittype have,want;
  542.   char havestr[81],wantstr[81];
  543.   char optchar;
  544.   char *userfile=0;
  545.   int quiet=0;
  546.  
  547.   extern char *optarg;
  548.   extern int optind;
  549.  
  550. #if defined(__SASC_650) && defined(_AMIGA)
  551.   if(argc == 0) {
  552.       /* Invoked from WorkBench... use WorkBench arguments
  553.        * Make sure <dos.h> was included earlier in order to
  554.        * declare _WBArgc and _WBArgv.                      
  555.        */
  556.       argc = _WBArgc;
  557.       argv = _WBArgv;
  558.   }
  559. #endif
  560.  
  561.   while (EOF != (optchar = getopt(argc,argv,"vqf:"))) {
  562.     switch(optchar) {
  563.       case 'f':
  564.         userfile=optarg;
  565.         break;
  566.       case 'q':
  567.         quiet=1;
  568.         break;
  569.       case 'v':
  570.         fprintf(stderr,"\n  %s  Copyright (c) 1993 by Adrian Mariano\n",VERSION+6);
  571.         fprintf(stderr,"                    This program may be freely distributed\n");
  572.         usage();
  573.       default:
  574.         usage();
  575.         break;
  576.      }
  577.   }
  578.     
  579.   if (optind != argc-2 && optind!=argc) usage();
  580.  
  581.   readunits(userfile);
  582.  
  583.   if (optind==argc-2){
  584.     strcpy(havestr,argv[optind]);
  585.     strcpy(wantstr,argv[optind+1]);
  586.     initializeunit(&have);
  587.     addunit(&have,havestr,0);
  588.     completereduce(&have);
  589.     initializeunit(&want);
  590.     addunit(&want,wantstr,0);
  591.     completereduce(&want);
  592.     showanswer(&have,&want);
  593.   } else {
  594.     if (!quiet) printf("%d units, %d prefixes\n\n",unitcount,prefixcount);
  595.     for(;;){
  596.       do{
  597.         initializeunit(&have);
  598.         if (!quiet) printf("You have: ");
  599.         if (!fgets(havestr,80,stdin)) { if (!quiet);putchar('\n');exit(0);}
  600.         if (!strnicmp(havestr, "quit", 4)){ if (!quiet);putchar('\n');exit(0);}
  601.       } while(addunit(&have,havestr,0) || completereduce(&have));
  602.       do{
  603.         initializeunit(&want);
  604.         if (!quiet) printf("You want: ");
  605.         if (!fgets(wantstr,80,stdin)) {if (!quiet) putchar('\n');exit(0);}
  606.         if (!strnicmp(wantstr, "quit", 4)){if (!quiet);putchar('\n');exit(0);}
  607.       } while(addunit(&want,wantstr,0) || completereduce(&want));
  608.       showanswer(&have,&want);
  609.     }
  610.   }
  611. }
  612.  
  613.  
  614.  
  615.  
  616.