home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 1 / RISC_DISC_1.iso / pd_share / code / meschach / !Meschach / c / zmatio < prev    next >
Encoding:
Text File  |  1994-01-12  |  10.4 KB  |  401 lines
  1.  
  2. /**************************************************************************
  3. **
  4. ** Copyright (C) 1993 David E. Steward & Zbigniew Leyk, all rights reserved.
  5. **
  6. **                 Meschach Library
  7. ** 
  8. ** This Meschach Library is provided "as is" without any express 
  9. ** or implied warranty of any kind with respect to this software. 
  10. ** In particular the authors shall not be liable for any direct, 
  11. ** indirect, special, incidental or consequential damages arising 
  12. ** in any way from use of the software.
  13. ** 
  14. ** Everyone is granted permission to copy, modify and redistribute this
  15. ** Meschach Library, provided:
  16. **  1.  All copies contain this copyright notice.
  17. **  2.  All modified copies shall carry a notice stating who
  18. **      made the last modification and the date of such modification.
  19. **  3.  No charge is made for this software or works derived from it.  
  20. **      This clause shall not be construed as constraining other software
  21. **      distributed on the same medium as this software, nor is a
  22. **      distribution fee considered a charge.
  23. **
  24. ***************************************************************************/
  25.  
  26.  
  27.  
  28. #include        <stdio.h>
  29. #include        <ctype.h>
  30. #include        "zmatrix.h"
  31.  
  32. static char rcsid[] = "$Id: zmatio.c,v 1.1 1994/01/13 04:25:18 des Exp $";
  33.  
  34.  
  35.  
  36. /* local variables */
  37. static char line[MAXLINE];
  38.  
  39. /**************************************************************************
  40.   Input routines
  41.   **************************************************************************/
  42.  
  43. complex    z_finput(fp)
  44. FILE    *fp;
  45. {
  46.     int        io_code;
  47.     complex    z;
  48.  
  49.     skipjunk(fp);
  50.     if ( isatty(fileno(fp)) )
  51.     {
  52.     do {
  53.         fprintf(stderr,"real and imag parts: ");
  54.         if ( fgets(line,MAXLINE,fp) == NULL )
  55.         error(E_EOF,"z_finput");
  56. #if REAL == DOUBLE
  57.         io_code = sscanf(line,"%lf%lf",&z.re,&z.im);
  58. #elif REAL == FLOAT
  59.         io_code = sscanf(line,"%f%f",&z.re,&z.im);
  60. #endif
  61.  
  62.     } while ( io_code != 2 );
  63.     }
  64.     else
  65. #if REAL == DOUBLE
  66.       if ( (io_code=fscanf(fp," (%lf,%lf)",&z.re,&z.im)) < 2 )
  67. #elif REAL == FLOAT
  68.       if ( (io_code=fscanf(fp," (%f,%f)",&z.re,&z.im)) < 2 )
  69. #endif
  70.         error((io_code == EOF) ? E_EOF : E_FORMAT,"z_finput");
  71.  
  72.     return z;
  73. }
  74.  
  75.  
  76. ZMAT    *zm_finput(fp,a)
  77. FILE    *fp;
  78. ZMAT    *a;
  79. {
  80.      ZMAT        *izm_finput(),*bzm_finput();
  81.      
  82.      if ( isatty(fileno(fp)) )
  83.       return izm_finput(fp,a);
  84.      else
  85.       return bzm_finput(fp,a);
  86. }
  87.  
  88. /* izm_finput -- interactive input of matrix */
  89. ZMAT     *izm_finput(fp,mat)
  90. FILE    *fp;
  91. ZMAT     *mat;
  92. {
  93.      char       c;
  94.      u_int      i, j, m, n, dynamic;
  95.      /* dynamic set to TRUE if memory allocated here */
  96.      
  97.      /* get matrix size */
  98.      if ( mat != ZMNULL && mat->m<MAXDIM && mat->n<MAXDIM )
  99.      {  m = mat->m;     n = mat->n;     dynamic = FALSE;        }
  100.      else
  101.      {
  102.       dynamic = TRUE;
  103.       do
  104.       {
  105.            fprintf(stderr,"ComplexMatrix: rows cols:");
  106.            if ( fgets(line,MAXLINE,fp)==NULL )
  107.             error(E_INPUT,"izm_finput");
  108.       } while ( sscanf(line,"%u%u",&m,&n)<2 || m>MAXDIM || n>MAXDIM );
  109.       mat = zm_get(m,n);
  110.      }
  111.      
  112.      /* input elements */
  113.      for ( i=0; i<m; i++ )
  114.      {
  115.      redo:
  116.       fprintf(stderr,"row %u:\n",i);
  117.       for ( j=0; j<n; j++ )
  118.            do
  119.            {
  120.            redo2:
  121.             fprintf(stderr,"entry (%u,%u): ",i,j);
  122.             if ( !dynamic )
  123.              fprintf(stderr,"old (%14.9g,%14.9g) new: ",
  124.                  mat->me[i][j].re,mat->me[i][j].im);
  125.             if ( fgets(line,MAXLINE,fp)==NULL )
  126.              error(E_INPUT,"izm_finput");
  127.             if ( (*line == 'b' || *line == 'B') && j > 0 )
  128.             {   j--;    dynamic = FALSE;        goto redo2;     }
  129.             if ( (*line == 'f' || *line == 'F') && j < n-1 )
  130.             {   j++;    dynamic = FALSE;        goto redo2;     }
  131.            } while ( *line=='\0' ||
  132. #if REAL == DOUBLE
  133.              sscanf(line,"%lf%lf",
  134. #elif REAL == FLOAT
  135.             sscanf(line,"%f%f",
  136. #endif    
  137.                 &mat->me[i][j].re,&mat->me[i][j].im)<1 );
  138.       fprintf(stderr,"Continue: ");
  139.       fscanf(fp,"%c",&c);
  140.       if ( c == 'n' || c == 'N' )
  141.       {    dynamic = FALSE;                 goto redo;      }
  142.       if ( (c == 'b' || c == 'B') /* && i > 0 */ )
  143.       {     if ( i > 0 )
  144.             i--;
  145.         dynamic = FALSE;        goto redo;
  146.       }
  147.      }
  148.      
  149.      return (mat);
  150. }
  151.  
  152. /* bzm_finput -- batch-file input of matrix */
  153. ZMAT     *bzm_finput(fp,mat)
  154. FILE    *fp;
  155. ZMAT     *mat;
  156. {
  157.      u_int      i,j,m,n,dummy;
  158.      int        io_code;
  159.      
  160.      /* get dimension */
  161.      skipjunk(fp);
  162.      if ((io_code=fscanf(fp," ComplexMatrix: %u by %u",&m,&n)) < 2 ||
  163.      m>MAXDIM || n>MAXDIM )
  164.       error(io_code==EOF ? E_EOF : E_FORMAT,"bzm_finput");
  165.      
  166.      /* allocate memory if necessary */
  167.      if ( mat==ZMNULL || mat->m<m || mat->n<n )
  168.       mat = zm_resize(mat,m,n);
  169.      
  170.      /* get entries */
  171.      for ( i=0; i<m; i++ )
  172.      {
  173.       skipjunk(fp);
  174.       if ( fscanf(fp," row %u:",&dummy) < 1 )
  175.            error(E_FORMAT,"bzm_finput");
  176.       for ( j=0; j<n; j++ )
  177.       {
  178.           /* printf("bzm_finput: j = %d\n", j); */
  179. #if REAL == DOUBLE
  180.           if ((io_code=fscanf(fp," ( %lf , %lf )",
  181. #elif REAL == FLOAT
  182.           if ((io_code=fscanf(fp," ( %f , %f )",
  183. #endif
  184.                   &mat->me[i][j].re,&mat->me[i][j].im)) < 2 )
  185.           error(io_code==EOF ? E_EOF : E_FORMAT,"bzm_finput");
  186.       }
  187.      }
  188.      
  189.      return (mat);
  190. }
  191.  
  192. ZVEC     *zv_finput(fp,x)
  193. FILE    *fp;
  194. ZVEC     *x;
  195. {
  196.      ZVEC        *izv_finput(),*bzv_finput();
  197.      
  198.      if ( isatty(fileno(fp)) )
  199.       return izv_finput(fp,x);
  200.      else
  201.       return bzv_finput(fp,x);
  202. }
  203.  
  204. /* izv_finput -- interactive input of vector */
  205. ZVEC     *izv_finput(fp,vec)
  206. FILE    *fp;
  207. ZVEC     *vec;
  208. {
  209.      u_int      i,dim,dynamic;  /* dynamic set if memory allocated here */
  210.      
  211.      /* get vector dimension */
  212.      if ( vec != ZVNULL && vec->dim<MAXDIM )
  213.      {  dim = vec->dim; dynamic = FALSE;        }
  214.      else
  215.      {
  216.       dynamic = TRUE;
  217.       do
  218.       {
  219.            fprintf(stderr,"ComplexVector: dim: ");
  220.            if ( fgets(line,MAXLINE,fp)==NULL )
  221.             error(E_INPUT,"izv_finput");
  222.       } while ( sscanf(line,"%u",&dim)<1 || dim>MAXDIM );
  223.       vec = zv_get(dim);
  224.      }
  225.      
  226.      /* input elements */
  227.      for ( i=0; i<dim; i++ )
  228.       do
  229.       {
  230.       redo:
  231.            fprintf(stderr,"entry %u: ",i);
  232.            if ( !dynamic )
  233.             fprintf(stderr,"old (%14.9g,%14.9g) new: ",
  234.                 vec->ve[i].re,vec->ve[i].im);
  235.            if ( fgets(line,MAXLINE,fp)==NULL )
  236.             error(E_INPUT,"izv_finput");
  237.            if ( (*line == 'b' || *line == 'B') && i > 0 )
  238.            {        i--;    dynamic = FALSE;        goto redo;         }
  239.            if ( (*line == 'f' || *line == 'F') && i < dim-1 )
  240.            {        i++;    dynamic = FALSE;        goto redo;         }
  241.       } while ( *line=='\0' ||
  242. #if REAL == DOUBLE
  243.             sscanf(line,"%lf%lf",
  244. #elif REAL == FLOAT
  245.             sscanf(line,"%f%f",
  246. #endif  
  247.                &vec->ve[i].re,&vec->ve[i].im) < 2 );
  248.      
  249.      return (vec);
  250. }
  251.  
  252. /* bzv_finput -- batch-file input of vector */
  253. ZVEC     *bzv_finput(fp,vec)
  254. FILE    *fp;
  255. ZVEC    *vec;
  256. {
  257.      u_int      i,dim;
  258.      int        io_code;
  259.      
  260.      /* get dimension */
  261.      skipjunk(fp);
  262.      if ((io_code=fscanf(fp," ComplexVector: dim:%u",&dim)) < 1 ||
  263.       dim>MAXDIM )
  264.      error(io_code==EOF ? 7 : 6,"bzv_finput");
  265.  
  266.      
  267.      /* allocate memory if necessary */
  268.      if ( vec==ZVNULL || vec->dim<dim )
  269.       vec = zv_resize(vec,dim);
  270.      
  271.      /* get entries */
  272.      skipjunk(fp);
  273.      for ( i=0; i<dim; i++ )
  274. #if REAL == DOUBLE
  275.       if ((io_code=fscanf(fp," (%lf,%lf)",
  276. #elif REAL == FLOAT
  277.           if ((io_code=fscanf(fp," (%f,%f)",
  278. #endif
  279.                   &vec->ve[i].re,&vec->ve[i].im)) < 2 )
  280.            error(io_code==EOF ? 7 : 6,"bzv_finput");
  281.      
  282.      return (vec);
  283. }
  284.  
  285. /**************************************************************************
  286.   Output routines
  287.   **************************************************************************/
  288. static char    *zformat = " (%14.9g, %14.9g) ";
  289.  
  290. char    *setzformat(f_string)
  291. char    *f_string;
  292. {
  293.     char    *old_f_string;
  294.     old_f_string = zformat;
  295.     if ( f_string != (char *)NULL && *f_string != '\0' )
  296.     zformat = f_string;
  297.  
  298.     return old_f_string;
  299. }
  300.  
  301. void    z_foutput(fp,z)
  302. FILE    *fp;
  303. complex    z;
  304. {
  305.     fprintf(fp,zformat,z.re,z.im);
  306.     putc('\n',fp);
  307. }
  308.  
  309. void    zm_foutput(fp,a)
  310. FILE    *fp;
  311. ZMAT     *a;
  312. {
  313.      u_int      i, j, tmp;
  314.      
  315.      if ( a == ZMNULL )
  316.      {  fprintf(fp,"ComplexMatrix: NULL\n");   return;         }
  317.      fprintf(fp,"ComplexMatrix: %d by %d\n",a->m,a->n);
  318.      if ( a->me == (complex **)NULL )
  319.      {  fprintf(fp,"NULL\n");           return;         }
  320.      for ( i=0; i<a->m; i++ )   /* for each row... */
  321.      {
  322.       fprintf(fp,"row %u: ",i);
  323.       for ( j=0, tmp=1; j<a->n; j++, tmp++ )
  324.       {             /* for each col in row... */
  325.            fprintf(fp,zformat,a->me[i][j].re,a->me[i][j].im);
  326.            if ( ! (tmp % 2) )       putc('\n',fp);
  327.       }
  328.       if ( tmp % 2 != 1 )   putc('\n',fp);
  329.      }
  330. }
  331.  
  332. void    zv_foutput(fp,x)
  333. FILE    *fp;
  334. ZVEC     *x;
  335. {
  336.      u_int      i, tmp;
  337.      
  338.      if ( x == ZVNULL )
  339.      {  fprintf(fp,"ComplexVector: NULL\n");   return;         }
  340.      fprintf(fp,"ComplexVector: dim: %d\n",x->dim);
  341.      if ( x->ve == (complex *)NULL )
  342.      {  fprintf(fp,"NULL\n");   return;         }
  343.      for ( i=0, tmp=0; i<x->dim; i++, tmp++ )
  344.      {
  345.       fprintf(fp,zformat,x->ve[i].re,x->ve[i].im);
  346.       if ( (tmp % 2) == 1 )   putc('\n',fp);
  347.      }
  348.      if ( (tmp % 2) != 0 )        putc('\n',fp);
  349. }
  350.  
  351.  
  352. void    zm_dump(fp,a)
  353. FILE    *fp;
  354. ZMAT     *a;
  355. {
  356.     u_int   i, j, tmp;
  357.      
  358.      if ( a == ZMNULL )
  359.      {  fprintf(fp,"ComplexMatrix: NULL\n");   return;         }
  360.      fprintf(fp,"ComplexMatrix: %d by %d @ 0x%lx\n",a->m,a->n,(long)a);
  361.      fprintf(fp,"\tmax_m = %d, max_n = %d, max_size = %d\n",
  362.          a->max_m, a->max_n, a->max_size);
  363.      if ( a->me == (complex **)NULL )
  364.      {  fprintf(fp,"NULL\n");           return;         }
  365.      fprintf(fp,"a->me @ 0x%lx\n",(long)(a->me));
  366.      fprintf(fp,"a->base @ 0x%lx\n",(long)(a->base));
  367.      for ( i=0; i<a->m; i++ )   /* for each row... */
  368.      {
  369.       fprintf(fp,"row %u: @ 0x%lx ",i,(long)(a->me[i]));
  370.       for ( j=0, tmp=1; j<a->n; j++, tmp++ )
  371.       {             /* for each col in row... */
  372.            fprintf(fp,zformat,a->me[i][j].re,a->me[i][j].im);
  373.            if ( ! (tmp % 2) )       putc('\n',fp);
  374.       }
  375.       if ( tmp % 2 != 1 )   putc('\n',fp);
  376.      }
  377. }
  378.  
  379.  
  380.  
  381. void    zv_dump(fp,x)
  382. FILE    *fp;
  383. ZVEC     *x;
  384. {
  385.      u_int      i, tmp;
  386.      
  387.      if ( ! x )
  388.      {  fprintf(fp,"ComplexVector: NULL\n");   return;         }
  389.      fprintf(fp,"ComplexVector: dim: %d @ 0x%lx\n",x->dim,(long)(x));
  390.      if ( ! x->ve )
  391.      {  fprintf(fp,"NULL\n");   return;         }
  392.      fprintf(fp,"x->ve @ 0x%lx\n",(long)(x->ve));
  393.      for ( i=0, tmp=0; i<x->dim; i++, tmp++ )
  394.      {
  395.       fprintf(fp,zformat,x->ve[i].re,x->ve[i].im);
  396.       if ( tmp % 2 == 1 )   putc('\n',fp);
  397.      }
  398.      if ( tmp % 2 != 0 )        putc('\n',fp);
  399. }
  400.  
  401.