home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / xplatfrm / units / u.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-11-02  |  17.8 KB  |  465 lines
  1. /* unit.c - 1/17/87 */
  2.  
  3. /*
  4.         Copyright 1987 Gregory R. Simpson
  5.  
  6. UUCP: {ihnp4, seismo, decwrl, philabs, ucbvax}!decvax!cwruecmp!ncoast!simpsong
  7. CSNET: ncoast!simpsong@case.CSNET     
  8. ARPA:  ncoast!simpsong%case.CSNET@Csnet-Relay.ARPA
  9. AT&T:  (216)-473-1019
  10.  
  11.         This notice and any statement of authorship must be reproduced
  12.         on all copies.  The author does not make any warranty expressed
  13.         or implied, or assumes any liability or responsiblity for the
  14.         use of this software.
  15.  
  16.         Any distributor of copies of this software shall grant the
  17.         recipient permission for further redistribution as permitted
  18.         by this notice.  Any distributor must distribute this software
  19.         without any fee or other monetary gains, unless expressed written
  20.         permission is granted by the author.
  21.  
  22.         This software or its use shall not be: sold, rented, leased,
  23.         traded, or otherwise marketed without the expressed written
  24.         permission of the author.
  25.  
  26.         If the software is modified in a manner creating derivative
  27.         copyrights, appropriate legends may be placed on derivative
  28.         work in addition to that set forth above.
  29.  
  30.         Permission is hereby granted to copy, reproduce, redistribute or
  31.         otherwise use this software as long as the conditions above
  32.         are meet.
  33.  
  34.         All rights not granted by this notice are reserved.
  35.  
  36.  (This copyright notice was written by, Kurt Zeilenga (zeilenga@hc.dspo.gov)
  37.   thanks Kurt... -greg)
  38.  
  39. */
  40. /* This program is for Unit Conversion... */
  41.  
  42. #include <stdio.h>
  43.  
  44. #define ESC '\033'
  45. #define True 1
  46.  
  47. /* Definition for clearing Screen */
  48.  
  49. #define Clear printf("%c[2J%c[1;1f",ESC,ESC)
  50.  
  51. #define MAXGROUP 20       /* Maximum Number of Unit Groups - 1 */
  52.  
  53. struct of_units {
  54.        char  *name;       /* Name of Unit */
  55.        float value;       /* Value - Initially set to 0 */
  56.        float conversion;  /* Conversion factor to Primary Unit */
  57.        int   counter;     /* Number of units in this group */
  58. } 
  59.  
  60. #include "unit_table.h"
  61.  
  62. main(argc, argv)
  63. int argc;
  64. char *argv[];
  65. {
  66.        int   group, user_unit, counter, unit_counter, sameunit;
  67.        int   comp_unit, ref_unit, chart, screen;
  68.        float user_value, from_value, to_value, temp_value, value, increment;
  69.        float primary;
  70.        char c[10], *cfile, chartfile[100];
  71.        FILE *fpchart;
  72.  
  73.        /* default values */
  74.  
  75.        group      = 1;
  76.        user_unit  = 1;
  77.        user_value = 1; 
  78.  
  79.        sameunit   = 0;  /* New Unit Group */
  80.        chart      = 0;  /* Default is standard conversion */
  81.  
  82.        /* check for chart option */
  83.  
  84.        if (argc > 2)   /* usage message if extra command line arguments */
  85.        {
  86.           usage();
  87.        } else if (argc > 1) {
  88.           if ( argv[1][0] == '-' ) {
  89.              if ( argv[1][1] == 'C' || argv[1][1] == 'c' ) {
  90.                 chart = 1;
  91.              } else {
  92.                 usage();
  93.              }
  94.           } else {
  95.             usage();
  96.           }
  97.        }
  98.        while(True)        /* loop forever... */
  99.        {
  100.            if ( sameunit == 0 ) 
  101.            {
  102.               Clear;
  103.               printf("                Unit Group Selection\n");
  104.               printf("-------------------------------------------------------------\n");
  105.               printf("1.  Length                  2. Mass                \n");
  106.               printf("3.  Speed                   4. Volume              \n");
  107.               printf("5.  Area                    6. Density             \n");
  108.               printf("7.  Time                    8. Force               \n");
  109.               printf("9.  Energy/Heat/Work       10. Pressure            \n");
  110.               printf("11. Angle                  12. Power               \n");
  111.               printf("13. Electric Charge        14. Magnetic Induction  \n");
  112.               printf("15. Light                  16. Thermal Conductivity\n");
  113.               printf("17. Coeff of Heat Transfer 18. Heat Flux           \n");
  114.               printf("19. Viscosity              20. Temperature         \n");
  115.               printf("21. Constants                                      \n");
  116.               printf("---------------------------------------------------(C)grs----\n");
  117.  
  118.  
  119.               printf("Which Type of Unit? ");
  120.               getinteger(&group, MAXGROUP);
  121.               group = group - 1;   /* since array starts at 0 */
  122.  
  123.               unit_counter = unit[group][1].counter - 1;
  124.         
  125.            } /* end of sameunit if */
  126.  
  127.               switch (group)
  128.               {
  129.                  case 19:
  130.                           temperature();
  131.                           sameunit = 0;
  132.                           break;
  133.                  case 20:
  134.                           constants();
  135.                           sameunit = 0;
  136.                           break;
  137.                  default:
  138.  
  139.               Clear;
  140.               printf("                     Unit Selection\n");
  141.               printf("-------------------------------------------------------------\n");
  142.               for (counter = 0; counter <= unit_counter; counter = counter+2)
  143.               {
  144.                      printf("%2d. %-18s                       %2d. %-18s\n",
  145.                      (counter + 1), unit[group][counter].name, 
  146.                      (counter + 2), unit[group][counter + 1].name);
  147.               }
  148.               printf("-------------------------------------------------------------\n");
  149.  
  150. /* --------------------   Standard Unit Conversion   ----------------  */
  151.  
  152.               if (chart == 0) {
  153.  
  154.                      printf("Your Unit? ");
  155.                      getinteger(&user_unit, unit_counter);
  156.                      user_unit = user_unit - 1;
  157.  
  158.                      printf("\nHow many %s ? ", unit[group][user_unit].name );
  159.                      getnumber(&user_value, unit_counter);
  160.  
  161.                      Clear;
  162.                      printf("\n     ============================================================\n");
  163.  
  164.                      primary=user_value*(1/unit[group][user_unit].conversion);
  165.  
  166.                      printf("     %16.8g %s is equivalent to:\n",
  167.                      user_value, unit[group][user_unit].name);
  168.                      printf("     ------------------------------------------------------------\n\n");
  169.                      for (counter = unit_counter; counter >= 0; counter--) 
  170.                      {
  171.                             if (counter != user_unit) 
  172.                             {
  173.                                    unit[group][counter].value = 
  174.                                    primary * unit[group][counter].conversion;
  175.                                    printf("                  %16.8g %-18s\n",
  176.                                    unit[group][counter].value,
  177.                                    unit[group][counter].name);
  178.                             }
  179.                      }
  180.  
  181.                      printf("     ============================================================\n");
  182.                      printf("\n      (R)erun Unit type, (N)ew Unit type, (Q)uit, or (C)hart: ");
  183.                      scanf("%s",c);
  184.                      if ( c[0] == 'Q' || c[0] == 'q' ) {
  185.                             printf("\n    U... Units conversion, by Gregory R. Simpson - Copyright 1987 \n");
  186.                             exit();
  187.                      } 
  188.                      else if ( c[0] == 'R' || c[0] == 'r' ) {
  189.                             sameunit = 1;
  190.                      } 
  191.                      else if ( c[0] == 'N' || c[0] == 'n' ) {
  192.                             sameunit = 0;
  193.                      } 
  194.                      else if ( c[0] == 'C' || c[0] == 'c' ) {
  195.                             chart = 1;
  196.                             sameunit = 0;
  197.                      }
  198.               } 
  199.  
  200. /* ---------------------  Chart Option   --------------------- */
  201.  
  202.               else {    
  203.  
  204.                      printf("\nYour Reference Unit?  ");
  205.                      getinteger(&ref_unit, unit_counter);
  206.                      ref_unit = ref_unit - 1;
  207.                      printf("Your Comparison Unit? ");
  208.                      getinteger(&comp_unit, unit_counter);
  209.                      comp_unit = comp_unit - 1;
  210.  
  211.                      printf("\nFrom How Many %s?  ", unit[group][ref_unit].name);
  212.                      getnumber(&from_value);
  213.                      printf("To How Many %s?    ", unit[group][ref_unit].name);
  214.                      getnumber(&to_value);
  215.                      printf("By what increment? ");
  216.                      getnumber(&increment);
  217.  
  218.                      screen = 0;
  219.                      printf("\nFilename for chart? (<CR> for screen): ");
  220.                      cfile = gets(chartfile);
  221.                      if (cfile[0] == '\0') {
  222.                         fpchart = stdout;
  223.                         screen  = 1;
  224.                      } 
  225.                      else if ( ( fpchart = fopen(cfile,"a") ) == NULL ) {
  226.                         fprintf(stderr, "Can't open Chartfile.");
  227.                         exit(1);
  228.                      }                      
  229.  
  230.                      Clear;
  231.  
  232.                      /* Error Checking and Correction... */
  233.  
  234.                      if ( from_value > to_value )
  235.                      {
  236.                         fprintf(fpchart,
  237.                         "Your From value is Greater than your To value.\n");
  238.                         fprintf(fpchart,"Therefore, I swapped them.\n");
  239.                         temp_value = from_value;
  240.                         from_value = to_value;
  241.                         to_value   = temp_value;
  242.                      }
  243.                      if ( increment < 0 )
  244.                      {
  245.                        fprintf(fpchart,
  246.                        "Since your From value is Less than your To value,\n");
  247.                        fprintf(fpchart,
  248.                        "I will make your increment positive.\n");
  249.                        increment = -increment;
  250.                      }
  251.  
  252.                      fprintf(fpchart,
  253. "------------------------------------------------------------------------------\n");
  254.  
  255.                      for (value = from_value; value <= to_value; 
  256.                           value = value + increment) 
  257.                          {
  258.                            primary=value*(1/unit[group][ref_unit].conversion);
  259.                             unit[group][comp_unit].value = 
  260.                              primary * unit[group][comp_unit].conversion;
  261.                              fprintf(fpchart,
  262.                              "| %16.8g %-18s | %16.8g %-18s |\n",
  263.                              value,unit[group][ref_unit].name,
  264.                              unit[group][comp_unit].value,
  265.                              unit[group][comp_unit].name);
  266.                              fprintf(fpchart,
  267. "------------------------------------------------------------------------------\n");
  268.                      }
  269.                      if (screen == 0) {
  270.                          fclose(fpchart);
  271.                      }
  272.                      printf("\n (R)erun Unit type, (N)ew Unit type, (Q)uit, or (S)tandard Conversions: ");
  273.                      scanf("%s",c);
  274.                      if ( c[0] == 'Q' || c[0] == 'q' ) {
  275.                             printf("\n    U... Unit Conversion, by Gregory R. Simpson - Copyright 1987 \n");
  276.                             exit();
  277.                      } 
  278.                      else if ( c[0] == 'R' || c[0] == 'r' ) {
  279.                             sameunit = 1;
  280.                      } 
  281.                      else if ( c[0] == 'N' || c[0] == 'n' ) {
  282.                             sameunit = 0;
  283.                      } 
  284.                      else if ( c[0] == 'S' || c[0] == 's' ) {
  285.                             chart = 0;
  286.                             sameunit = 0;
  287.                      }
  288.  
  289.               } /* end of chart if else */
  290.           } /* end of switch */
  291.        } /* end of while */
  292. } /* ---- end of main program ---- */
  293.  
  294. /* getinteger - Get Positive Integer Routine - G.R.Simpson */
  295.  
  296. int getinteger(choice, max)
  297.  
  298. int *choice;
  299. int max;
  300. {
  301.        int status, c;
  302.        while(1) { 
  303.               status = scanf("%d", choice);
  304.               if (status == 0)
  305.               {
  306.                      scanf("%*s");
  307.                      printf("Please Use Positive Integers; try again: ");
  308.               }
  309.               else if (status == 1)
  310.               {
  311.                      while ((c = getchar()) != '\n' && c != EOF)
  312.                             ;
  313.                      if ( c == EOF )
  314.                      {
  315.                             ungetc(c, stdin);
  316.                      }
  317.                      if ( *choice > 0 && *choice <= max+1 ) 
  318.                      {
  319.                              return status;
  320.                      }
  321.                      printf("Please use a number from 1 to %d : ", max+1);
  322.               }
  323.               else  /* status is -1 */
  324.               {
  325.               printf("End of file encountered... \n");
  326.               *choice = 1;
  327.               return status;
  328.               }
  329. }
  330. }
  331.  
  332. /* getfloat - Get Floating Point Number - G.R.Simpson */
  333.  
  334. getnumber(fchoice)
  335.  
  336. float *fchoice;
  337. {
  338.        int status, c;
  339.        while( (status = scanf("%f", fchoice)) == 0)
  340.        {
  341.               scanf("%*s");
  342.               printf("Please Use Numeric Input; try again: ");
  343.        }
  344.        if (status == 1)
  345.        {
  346.               while ((c = getchar()) != '\n' && c != EOF)
  347.                      ;
  348.               if ( c == EOF )
  349.                      ungetc(c, stdin);
  350.        }
  351.        else  /* status is -1 */
  352.        printf("End of file encountered... \n");
  353.        return status;
  354. }
  355.  
  356. /* usage - Print a usage message - G.R.Simpson */
  357.  
  358. usage()
  359. {
  360.         printf("\nusage: u [-c] \n");
  361.         printf("-c : unit chart option \n\n");
  362.         printf("U... Unit conversions; Copyright, Gregory R. Simpson 1987\n");
  363.         exit();
  364. }
  365.  
  366. /* temperature - G.R.Simpson */
  367.  
  368. temperature()
  369. {
  370. static char *scale[4] = { "Fahrenheit", "Celsius", "Rankine", "Kelvin" };
  371. float fahrenheit, celsius, rankine, kelvin;
  372. float temp;
  373. char c[2];
  374. int    choice, tempagain;
  375.  
  376.         tempagain = 1;
  377.  
  378.         while(tempagain) {
  379.               Clear;
  380.               printf("                     Unit Selection\n");
  381.               printf("-------------------------------------------------------------\n");
  382.                      printf("1. Fahrenheit                    2. Celsius \n");
  383.                      printf("3. Rankine                       4. Kelvin \n");
  384.               printf("-------------------------------------------------------------\n");
  385.  
  386.         printf("Your Temperature Scale? ");
  387.         getinteger(&choice,3);
  388.         printf("\n How many degrees %s? ", scale[choice-1]);
  389.         getnumber(&temp);
  390.         switch(choice) {
  391.               case 1 :
  392.                     fahrenheit = temp;
  393.                     break;
  394.               case 2 :
  395.                     fahrenheit = temp*(9.0/5.0) + 32.0;
  396.                     break;
  397.               case 3 :
  398.                     fahrenheit = temp - 459.67;
  399.                     break;
  400.               case 4 :
  401.                     fahrenheit = ((temp-273.15)*(9.0/5.0)) + 32.0;
  402.                     break;
  403.         }
  404.         celsius = (fahrenheit - 32) * (5.0/9.0);
  405.         rankine = fahrenheit + 459.67;
  406.         kelvin  = celsius + 273.15;
  407.  
  408.         Clear;
  409.         printf("     %16.8g degrees %s is equivalent to:\n",
  410.                      temp,scale[choice-1]);
  411.         printf("                  ------------------------------------\n");
  412.         if (choice != 1) printf("                  %16.8g degrees Fahrenheit\n", fahrenheit);
  413.         if (choice != 2) printf("                  %16.8g degrees Celsius\n",    celsius);
  414.         if (choice != 3) printf("                  %16.8g degrees Rankine\n",    rankine);
  415.         if (choice != 4) printf("                  %16.8g degrees Kelvin\n",     kelvin);
  416.  
  417.         printf("                  ------------------------------------\n");
  418.         printf("\n (R)erun Unit type, (N)ew Unit type, or (Q)uit: ");
  419.         scanf("%s",c);
  420.         if ( c[0] == 'Q' || c[0] == 'q' ) {
  421.            printf("\n    U... Unit Conversion, by Gregory R. Simpson - Copyright 1987 \n");
  422.            exit();
  423.         } 
  424.         else if ( c[0] == 'R' || c[0] == 'r' ) {
  425.            tempagain = 1;
  426.         } 
  427.         else if ( c[0] == 'N' || c[0] == 'n' ) {
  428.            tempagain = 0;
  429.         } 
  430.   } /* end while(tempagain) */
  431.         c[0] = '\0';
  432.         return;
  433. }
  434.  
  435. /* constants - G.R.Simpson */
  436.  
  437. constants()
  438. {
  439.         char c[10];
  440.  
  441.         Clear;         
  442.         printf("\npi                      =  3.141592653589793238462643\n");
  443.         printf("e                       =  2.718281828459045235360287\n");
  444.         printf("atomic mass unit        =  1.66053 e-27 kg, e-24 gm \n");
  445.         printf("Avogadro's number N     =  6.02217 e23 mole^-1 \n");
  446.         printf("Boltzmann's constant    =  R/N = 1.3806 e-23 J/K, e-16 erg/K = 8.61708 e-5 eV/K \n");
  447.         printf("gas constant            =  8.3143 J/mole-K = 0.082054 l-atm/mole-K\n");
  448.         printf("gravitational constant  =  6.673 e-11 N-m^2/kg^2, J-m/kg^2, \n");
  449.         printf("mass of electron        =  9.10956 e-31 kg, e-28 gm =  5.48593 e-4 amu \n");
  450.         printf("mass of proton          =  1.67261 e-27 kg, e-24 gm =  1.0072766 amu \n");
  451.         printf("Planck's constant       =  h =  6.62620 e-34 J-sec,  e-27 erg-sec \n");
  452.         printf("h bar                   =  h/2*pi = 1.05459 e-34 J-sec, e-27 erg-sec \n");
  453.         printf("speed of light          =  2.997925 e8 m/sec, e10 cm/sec \n");
  454.         printf("Stefan-Boltzmann constant =  5.670 e-8 W/m^2-K^4 \n");
  455.         printf("\n      <CR> to continue or (Q)uit: ");
  456.         gets(c);
  457.         if ( c[0] == 'Q' || c[0] == 'q' ) {
  458.            printf("\n    U... Unit Conversion, by Gregory R. Simpson - Copyright 1987 \n");
  459.            exit();
  460.         } else {
  461.         c[0] = '\0';
  462.         return;
  463.         }
  464. }
  465.