home *** CD-ROM | disk | FTP | other *** search
/ pc.louisiana.edu/pub/unix/ / Louisiana_UNIX.tar / Louisiana_UNIX / xspread3.0.zoo / matrix.c < prev    next >
C/C++ Source or Header  |  1994-04-29  |  34KB  |  1,006 lines
  1. /*    SC    A Spreadsheet Calculator
  2.  *        Command routines
  3.  *
  4.  *        original by James Gosling, September 1982
  5.  *        modifications by Mark Weiser and Bruce Israel,
  6.  *            University of Maryland
  7.  *
  8.  *              More mods Robert Bond, 12/86
  9.  *
  10.  *        $Revision: 6.21 A $
  11.  *
  12.  *        Modified by Dan Coppersmith, 5/94
  13.  */
  14.  
  15. #include <sys/types.h>
  16. #include <ctype.h>
  17. #include "config.h"
  18. #ifdef DOINGX
  19. #include <stdio.h>
  20. #else
  21. #include <curses.h>
  22. #endif
  23.  
  24. #include "sc.h"
  25.  
  26. /* next two structures move to sc.h by Bob Parbs 12-92 */
  27. /*struct m_range_sd {             
  28.        int ssr,ser,ssc,sec;
  29.        int dsr,der,dsc,dec;
  30.       };*/
  31. /*struct m_range {
  32.        int sr,er,sc,ec;
  33.       };*/
  34. struct m_range_sd *rge_sd;
  35. struct m_range *rge_s1, *rge_s2, *rge_d;
  36.  
  37. /*#define MAXCOLS 702*/   /* temp adds by Bob Parbs 12-92 */
  38. /*#define MAXROWS 2500*/
  39.  
  40. #ifdef __STDC__
  41. void get_trans();
  42. struct m_range_sd *find_rge(char *);
  43. int convert(int, char [], int );
  44. void transpose(int, int, int, int, int, int);
  45. void get_add();
  46. struct m_range *findrge(char *);
  47. void addmatrix(int, int, int, int, int, int,int,int,int,int);
  48. void get_sub();
  49. void submatrix(int, int, int, int, int, int,int,int,int,int); 
  50. void get_mult();
  51. void multmatrix1(int, int, int, int, int, int,int ,int ,int ,int ); 
  52. void multmatrix(int , int , int , int , int , int ,int ,int ,int ,int ); 
  53. void get_invert(); 
  54. void invertmatrix(int , int , int , int , int , int ); 
  55. #endif
  56.  
  57. /***************************************************************************/
  58. /*                                                                         */
  59. /* The following function calculate the transpose matrix of the input one  */
  60. /*                                                                         */
  61. /*                                            -Fang Wang   12/91           */
  62. /***************************************************************************/
  63. /* REG_LEN moved to sc.h by Bob Parbs 12-92 */
  64. /*#define REG_LEN 28  length of input range string*/
  65. void get_trans()      /* void added by Bob Parbs 12-92 */
  66. {
  67.     char s[100];
  68.     struct m_range_sd *find_rge(), *rge_sd;
  69.     struct ent *dv1,*dv2,*v1,*v2;
  70.     int minsr, minsc;
  71.     int maxsr, maxsc;
  72.     int mindr, mindc;
  73.     int maxdr, maxdc;
  74.     int vr, vc;
  75.     int r, c;
  76.  
  77.   sprintf(s, "transpose [dest_range src_range] ");
  78.   get_str(s,REG_LEN);
  79.   rge_sd=find_rge(s);
  80.   /*check for input error*/
  81.   if (rge_sd == NULL) {
  82.       error ("Input syntax");
  83.       return;
  84.    } 
  85.     dv1=lookat(rge_sd->dsr,rge_sd->dsc);
  86.     dv2=lookat(rge_sd->der,rge_sd->dec);
  87.     v1=lookat(rge_sd->ssr,rge_sd->ssc);
  88.     v2=lookat(rge_sd->ser,rge_sd->sec);
  89.     mindr = dv1->row;
  90.     mindc = dv1->col;
  91.     maxdr = dv2->row;
  92.     maxdc = dv2->col;
  93.     if (mindr>maxdr) r = maxdr, maxdr = mindr, mindr = r;
  94.     if (mindc>maxdc) c = maxdc, maxdc = mindc, mindc = c;
  95.     maxsr = v2->row;
  96.     maxsc = v2->col;
  97.     minsr = v1->row;
  98.     minsc = v1->col;
  99.     if (minsr>maxsr) r = maxsr, maxsr = minsr, minsr = r;
  100.     if (minsc>maxsc) c = maxsc, maxsc = minsc, minsc = c;
  101.     /*if (maxdr >= MAXROWS  || maxdc >= MAXCOLS) {
  102.         error ("The table can't be any bigger");
  103.         return;
  104.     }*/   /* commented out by Bob Parbs 12-92 */
  105.     /*check for the matching of size of matrices*/
  106.     if (((maxsr-minsr) != (maxdc-mindc)) || ((maxsc-minsc) != (maxdr-mindr)))
  107.     {
  108.         error("Destination matrix range, source matrix range don't match");
  109.         return;
  110.     }
  111.     erase_area(mindr, mindc, maxdr, maxdc); /*clear the des. area*/
  112.     if (minsr == maxsr && minsc == maxsc) {
  113.         /* Source is a single cell */
  114.         for(vr = mindr; vr <= maxdr; vr++)
  115.             for (vc = mindc; vc <= maxdc; vc++)
  116.                 transpose(vr, vc, minsr, minsc, maxsr, maxsc);
  117.     } else if (minsr == maxsr) {
  118.         /* Source is a single row */
  119.         for (vc = mindc; vc <= maxdc; vc++)
  120.             transpose( mindr,vc, minsr, minsc, maxsr, maxsc);
  121.     } else if (minsc == maxsc) {
  122.         /* Source is a single column */
  123.         for (vr = mindr; vr <= maxdr; vr++)
  124.             transpose(vr, mindc, minsr, minsc, maxsr, maxsc);
  125.     } else {
  126.         /* Everything else */
  127.         transpose(mindr, mindc, minsr, minsc, maxsr, maxsc);
  128.     }
  129. }
  130.  
  131. /*#ifdef notdef  SILLY PEOPLE... */
  132. /***************************************************************************/
  133. /*                                                                         */
  134. /* The following function find the range upper left corner row,upper col   */
  135. /* and  bottom right corner row and col.                                   */
  136. /*                                                                         */
  137. /*                                            -Fang Wang   12/91           */
  138. /***************************************************************************/
  139.  
  140. /* ROWLIM, COLIM moved to sc.h by Bob Parbs 12-92 */
  141. /*#define ROWLIM 4 size of the array stores col label*/
  142. /*#define COLIM 3 size of the array stores row label*/
  143. struct m_range_sd *find_rge(s)
  144. char *s;
  145.  
  146. { char col[COLIM],row[ROWLIM];
  147.   int i, j, mtemp[9];
  148.   struct m_range_sd *rge_sd;
  149.  
  150.   for (i=0;i<=8;i++)
  151.      mtemp[i] = 0;
  152.   j = 0;
  153.   while (*s != '\0') {
  154.      i = 0;
  155.      if ((*s == ':') || (*s == ' '))  s++;
  156.      while (((*s <= 'Z') && (*s >= 'A')) || ((*s <= 'z') && (*s >= 'a')))
  157.           col[i++] = *(s++);
  158.      col[i] = '\0';
  159.      if ((strlen(col) == 0 ) || (strlen(col) > (COLIM-1)))
  160.          return(NULL);
  161.      mtemp[j++] = convert(26,col,strlen(col));
  162.      i = 0;
  163.      while ((*s<='9') && (*s>='0'))
  164.           row[i++] = *(s++);
  165.      row[i] = '\0';
  166.      if ((strlen(row) == 0 ) || (strlen(row) > (ROWLIM-1)))
  167.          return(NULL);
  168.      mtemp[j++] = convert(10,row,strlen(row));
  169.   } /* end of while*/
  170.   /* altered by Bob Parbs */
  171.   rge_sd = (struct m_range_sd *) scxmalloc(sizeof(struct m_range_sd));
  172.   rge_sd->dsc = mtemp[0];
  173.   rge_sd->dsr = mtemp[1];
  174.   rge_sd->dec = mtemp[2];
  175.   rge_sd->der = mtemp[3];
  176.   rge_sd->ssc = mtemp[4];
  177.   rge_sd->ssr = mtemp[5];
  178.   rge_sd->sec = mtemp[6];
  179.   rge_sd->ser = mtemp[7];
  180.   return(rge_sd);
  181. }
  182.  
  183. /***************************************************************************
  184.  *                                                                         *
  185.  *    Convert the col, row into integer.                                   *
  186.  *                                     -Fang Wang  12/91                   *
  187.  **************************************************************************/
  188.  
  189. int convert( base, s, size)
  190. int base,size;
  191. char s[];
  192.  
  193. { int val, i;
  194.   int temp;
  195.  
  196.   temp = 0;
  197.   val = 0;
  198.   for (i=0; (i<size) && (s[i] != '\0'); i++) {
  199.       if (((s[i]<='Z') && (s[i]>='A')) || ((s[i]<='z') && (s[i]>='a'))) {
  200.           if (islower(s[i]))
  201.                s[i] = toupper(s[i]);
  202.       val = (temp*base) + ( s[i]-'A');
  203.       temp = temp + 1;
  204.       }
  205.       else if ((s[i]<='9') && (s[i]>='0'))
  206.           val = (val*base) + (s[i]-'0');
  207.    }
  208.    return (val);
  209. }
  210. /*#endif*/
  211.  
  212. /***************************************************************************
  213.  *                                                                         *
  214.  *    Calculates the transpose matrix.                                     *
  215.  *                                                                         *
  216.  *                                     -Fang Wang  12/91                   *
  217.  **************************************************************************/
  218.  
  219.  
  220. void transpose(vr, vc, minsr, minsc, maxsr, maxsc) /* void added Bob Parbs */
  221. int vr, vc, minsr, minsc, maxsr, maxsc;
  222. {
  223.     register struct ent *p;
  224.     register struct ent *n;
  225.     register int sr, sc;
  226.     register int dr, dc;
  227.  
  228.     for (dc=vc, sr=minsr; sr<=maxsr; sr++, dc++) 
  229.        for (dr=vr, sc=minsc; sc<=maxsc; sc++, dr++) {
  230.             n = lookat (dr, dc);
  231.             (void) clearent(n);
  232.             if (p = *ATBL(tbl, sr, sc))
  233.                 copyent( n, p, dr - sr, dc - sc);
  234.         }
  235. }
  236.  
  237.  
  238. /***************************************************************************
  239.  *                                                                         *
  240.  *    Add two matrices.                                                    *
  241.  *                                                                         *
  242.  *                                     -Fang Wang  12/91                   *
  243.  ***************************************************************************/
  244.  
  245. /* TSSIZE move to sc.h Bob Parbs 12-92 */
  246. /*#define TSSIZE 15*/
  247. void get_add()       /* void added Bob Parbs 12-92 */
  248. {
  249.   char s[100];
  250.   struct m_range *findrge(),*rge_s1,*rge_s2,*rge_d;
  251.   struct ent *dmin,*dmax,*s1min,*s1max,*s2min,*s2max;
  252.   int mins1r, mins1c;
  253.   int maxs1r, maxs1c;
  254.   int mins2r, mins2c;
  255.   int maxs2r, maxs2c;
  256.   int mindr, mindc;
  257.   int maxdr, maxdc;
  258.   int vr, vc;
  259.   int r, c;
  260.  
  261. /*#ifdef notdef*/
  262.   sprintf(s,"1st matrix range:");
  263.   get_str(s,TSSIZE);
  264.   rge_s1 = findrge(s);
  265.   if (rge_s1 == NULL) {
  266.      error("Input syntax error");
  267.      return;
  268.   }
  269.   clearlines(0,0);
  270.   sprintf(s,"2nd matrix range:");
  271.   get_str(s,TSSIZE);
  272.   rge_s2 = findrge(s);
  273.   if (rge_s2 == NULL) {
  274.      error("Input syntax error");
  275.      return;
  276.   }
  277.   clearlines(0,0);
  278.   sprintf(s,"result matrix range:");
  279.   get_str(s,TSSIZE);
  280.   rge_d = findrge(s);
  281.   if (rge_d == NULL) {
  282.      error("Input syntax error");
  283.      return;
  284.   }
  285. /*#endif*/
  286.   dmin=lookat(rge_d->sr,rge_d->sc);
  287.   dmax=lookat(rge_d->er,rge_d->ec);
  288.   s1min=lookat(rge_s1->sr,rge_s1->sc);
  289.   s1max=lookat(rge_s1->er,rge_s1->ec);
  290.   s2min=lookat(rge_s2->sr,rge_s2->sc);
  291.   s2max=lookat(rge_s2->er,rge_s2->ec);
  292.   mindr=dmin->row;
  293.   mindc=dmin->col;
  294.   maxdr=dmax->row;
  295.   maxdc=dmax->col;
  296.   if (mindr>maxdr) r = maxdr, maxdr = mindr, mindr = r;
  297.   if (mindc>maxdc) c = maxdc, maxdc = mindc, mindc = c;
  298.   maxs1r = s1max->row;
  299.   maxs1c = s1max->col;
  300.   mins1r = s1min->row;
  301.   mins1c = s1min->col;
  302.   maxs2r = s2max->row;
  303.   maxs2c = s2max->col;
  304.   mins2r = s2min->row;
  305.   mins2c = s2min->col;
  306.   if (mins1r>maxs1r) r = maxs1r, maxs1r = mins1r, mins1r = r;
  307.   if (mins1c>maxs1c) c = maxs1c, maxs1c = mins1c, mins1c = c;
  308.   if (mins2r>maxs2r) r = maxs2r, maxs2r = mins2r, mins2r = r;
  309.   if (mins2c>maxs2c) c = maxs2c, maxs2c = mins2c, mins2c = c;
  310.   /*if (maxdr >= MAXROWS  ||
  311.          maxdc >= MAXCOLS) {
  312.      error ("The table can't be any bigger");
  313.      return;
  314.   }*/         /* commented out by Bob Parbs 12-92 */
  315.   if (((maxs1r-mins1r) != (maxs2r-mins2r)) ||
  316.                       ((maxs2c-mins2c) != (maxs1c-mins1c))) {
  317.       error("Size of two matrices don't match, can't be added");
  318.       return;
  319.      }
  320.   if (((maxs1r-mins1r) != (maxdr-mindr)) ||
  321.                       ((maxdc-mindc) != (maxs1c-mins1c))) {
  322.       error("Size of source and destination matrices don't match");
  323.       return;
  324.      }
  325.   erase_area(mindr, mindc, maxdr, maxdc);
  326.   if (mins1r == maxs1r && mins1c == maxs1c && mins2r == maxs2r &&
  327.         mins2c == maxs2c )  {
  328.         /* Source is a single cell */
  329.         for(vr = mindr; vr <= maxdr; vr++)
  330.             for (vc = mindc; vc <= maxdc; vc++)
  331.                addmatrix(vr, vc, mins1r, mins1c, maxs1r, maxs1c,
  332.                                  mins2r, mins2c, maxs2r, maxs2c);
  333.     } else if (mins1r == maxs1r && mins2r == maxs2r) {
  334.         /* Source is a single row */
  335.         for (vr = mindr; vr <= maxdr; vr++)
  336.                addmatrix(vr,mindc, mins1r, mins1c, maxs1r, maxs1c,
  337.                                  mins2r, mins2c, maxs2r, maxs2c);
  338.     } else if (mins1c == maxs1c && mins2c == maxs2c ) {
  339.         /* Source is a single column */
  340.         for (vc = mindc; vc <= maxdc; vc++)
  341.            addmatrix(mindr, vc, mins1r, mins1c, maxs1r, maxs1c,
  342.                                  mins2r, mins2c, maxs2r, maxs2c);
  343.     } else {
  344.         /* Everything else */
  345.         addmatrix(mindr, mindc, mins1r, mins1c, maxs1r, maxs1c,
  346.                                  mins2r, mins2c, maxs2r, maxs2c);
  347.     }
  348. }
  349.  
  350. /*#ifdef notdef  SILLY */
  351. /***************************************************************************
  352.  *                                                                         *
  353.  *    Get range for when input one by one.                                 *
  354.  *                                                                         *
  355.  *                                     -Fang Wang  12/91                   *
  356.  ***************************************************************************/
  357. /* ROWLIM, COLIM moved to sc.h Bob Parbs 12-92 */
  358. /*#define ROWLIM 4*/
  359. /*#define COLIM 3*/
  360.  
  361. struct m_range *findrge(s)
  362. char *s;
  363.  
  364. { char col[COLIM],row[ROWLIM];
  365.   int i, j, mtemp[5];
  366.   struct m_range *rge;
  367.  
  368.   for (i=0;i<=4;i++)
  369.      mtemp[i] = 0;
  370.   j = 0;
  371.   while (*s != '\0') {
  372.      i = 0;
  373.      if (*s == ':')  s++;
  374.      while (((*s <= 'Z') && (*s >= 'A')) || ((*s <= 'z') && (*s >= 'a')))
  375.           col[i++] = *(s++);
  376.      col[i] = '\0';
  377.      if ((strlen(col) == 0 ) || (strlen(col) > (COLIM-1)))
  378.           return(NULL);
  379.      mtemp[j++] = convert(26,col,strlen(col));
  380.      i = 0;
  381.      while ((*s<='9') && (*s>='0'))
  382.           row[i++] = *(s++);
  383.      row[i] = '\0';
  384.      if ((strlen(row) == 0 ) || (strlen(row) > (ROWLIM-1)))
  385.          return(NULL);
  386.      mtemp[j++] = convert(10,row,strlen(row)); 
  387.   } /* end of while*/
  388.   /* altered by Bob Parbs 12-92 */
  389.   rge = (struct m_range *) scxmalloc(sizeof(struct m_range));
  390.   rge->sc = mtemp[0];
  391.   rge->sr = mtemp[1];
  392.   rge->ec = mtemp[2];
  393.   rge->er = mtemp[3];
  394.   return(rge);
  395. } 
  396. /*#endif*/
  397.  
  398. /***************************************************************************
  399.  *                                                                         *
  400.  *    Calculates addition of two matrices.                                 *
  401.  *                                                                         *
  402.  *                                     -Fang Wang  12/91                   *
  403.  ***************************************************************************/
  404.  
  405. /* Function now works 12-92 Bob Parbs */
  406.  
  407. /* MAXSS no longer needed Bob Parbs 12-92 */
  408. /*#define MAXSS 2000*/
  409. void addmatrix(vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c)
  410. /* void added Bob Parbs 12-92 */
  411. int vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c;
  412. {
  413.     register struct ent *p1,*p2;
  414.     register struct ent *n;
  415.     register int s1r, s1c, s2r, s2c;
  416.     register int dr, dc;
  417.     /*int i,j;*/    /* no longer needed B.P. */
  418.     /*int list1[MAXSS],list2[MAXSS];*/ /*commented out by Bob Parbs 12-92 */
  419.  
  420.     /* lists no longer needed as values added to dest as read */
  421.     /* used to only add int parts, now adds entire entries  Bob Parbs */
  422.  
  423.  
  424.     /* following loops to fill list1, list 2 no longer needed B.P. */ 
  425.      /*for (i=0;i<=MAXSS;i++)
  426.         {
  427.             list1[i] = 0;
  428.             list2[i] = 0;
  429.         } 
  430.      i = 0;
  431.      for (s1r=mins1r;s1r<=maxs1r;s1r++)
  432.         for (s1c=mins1c;s1c<=maxs1c;s1c++)
  433.             if ((p1 = *ATBL(tbl, s1r, s1c)) && p1->flags&is_valid)
  434.                    list1[i++] = p1->v;
  435.      j = 0;
  436.      for (s2r=mins2r;s2r<=maxs2r;s2r++)
  437.         for (s2c=mins2c;s2c<=maxs2c;s2c++)
  438.             if ((p2 = *ATBL(tbl, s2r, s2c)) && p2->flags&is_valid)
  439.                   list2[j++] = p2->v;
  440.      for (i=0;i<=MAXSS;i++)
  441.           list1[i] = list1[i] + list2[i];
  442.      i = 0;*/
  443.  
  444.      /* altered the following to add entries as read  Bob Parbs 12-92 */
  445.      /* add much shorter now and works correctly B.P. */
  446.  
  447.      for (dr=vr, s1r=mins1r,s2r=mins2r; s1r<=maxs1r; s1r++,dr++,s2r++)
  448.        for (dc=vc, s1c=mins1c,s2c=mins2c; s1c<=maxs1c; s1c++, dc++,s2c++) {
  449.             n = lookat (dr, dc);
  450.             (void) clearent(n);
  451.             if ((p2 = *ATBL(tbl,s2r,s2c))&&(p2->flags&is_valid)){
  452.             if ((p1 = *ATBL(tbl, s1r, s1c)) && (p1->flags&is_valid))
  453.                 {
  454.                    copyent( n, p1, dr - s1r, dc - s1c);
  455.                    n->v = (p1->v+p2->v);
  456.                  }}
  457.             }
  458. }
  459.  
  460. /***************************************************************************
  461.  *                                                                         *
  462.  *    Subtraction of two matrices.                                         *
  463.  *                                                                         *
  464.  *                                     -Fang Wang  12/91                   *
  465.  ***************************************************************************/
  466. /* TSSIZE moved to sc.h Bob Parbs 12-92 */
  467. /*#define TSSIZE 15*/
  468. void get_sub()    /* void added Bob Parbs 12-92 */
  469. {
  470.   char s[100];
  471.   struct m_range *findrgt(),*rge_s1,*rge_s2;
  472.   struct ent *dmin,*dmax,*s1min,*s1max,*s2min,*s2max;
  473.   int mins1r, mins1c;
  474.   int maxs1r, maxs1c;
  475.   int mins2r, mins2c;
  476.   int maxs2r, maxs2c;
  477.   int mindr, mindc;
  478.   int maxdr, maxdc;
  479.   int vr, vc;
  480.   int r, c;
  481.  
  482.   sprintf(s,"1st matrix range:");
  483.   get_str(s,TSSIZE);
  484.   rge_s1 = findrge(s);
  485.   if (rge_s1 == NULL ) {
  486.      error ("Input syntax error");
  487.      return;
  488.   }
  489.   clearlines(0,0);
  490.   sprintf(s,"2nd matrix range:");
  491.   get_str(s,TSSIZE);
  492.   rge_s2 = findrge(s);
  493.   if (rge_s2 == NULL ) {
  494.      error ("Input syntax error");
  495.      return;
  496.   }
  497.   clearlines(0,0);
  498.   sprintf(s,"result matrix range:");
  499.   get_str(s,TSSIZE);
  500.   rge_d = findrge(s);
  501.   if (rge_s2 == NULL ) {
  502.      error ("Input syntax error");
  503.      return;
  504.   }
  505.   dmin=lookat(rge_d->sr,rge_d->sc);
  506.   dmax=lookat(rge_d->er,rge_d->ec);
  507.   s1min=lookat(rge_s1->sr,rge_s1->sc);
  508.   s1max=lookat(rge_s1->er,rge_s1->ec);
  509.   s2min=lookat(rge_s2->sr,rge_s2->sc);
  510.   s2max=lookat(rge_s2->er,rge_s2->ec);
  511.   mindr=dmin->row;
  512.   mindc=dmin->col;
  513.   maxdr=dmax->row;
  514.   maxdc=dmax->col;
  515.   if (mindr>maxdr) r = maxdr, maxdr = mindr, mindr = r;
  516.   if (mindc>maxdc) c = maxdc, maxdc = mindc, mindc = c;
  517.   maxs1r = s1max->row;
  518.   maxs1c = s1max->col;
  519.   mins1r = s1min->row;
  520.   mins1c = s1min->col;
  521.   maxs2r = s2max->row;
  522.   maxs2c = s2max->col;
  523.   mins2r = s2min->row;
  524.   mins2c = s2min->col;
  525.   if (mins1r>maxs1r) r = maxs1r, maxs1r = mins1r, mins1r = r;
  526.   if (mins1c>maxs1c) c = maxs1c, maxs1c = mins1c, mins1c = c;
  527.   if (mins2r>maxs2r) r = maxs2r, maxs2r = mins2r, mins2r = r;
  528.   if (mins2c>maxs2c) c = maxs2c, maxs2c = mins2c, mins2c = c;
  529.   /*if (maxdr >= MAXROWS  ||
  530.          maxdc >= MAXCOLS) {
  531.      error ("The table can't be any bigger");
  532.      return;
  533.   }*/       /* commented out by Bob Parbs 12-92 */
  534.   if (((maxs1r-mins1r) != (maxs2r-mins2r)) ||
  535.                       ((maxs2c-mins2c) != (maxs1c-mins1c))) {
  536.       error("Size of two matrices don't match, can't be subtracted");
  537.       return;
  538.      }
  539.   if (((maxs1r-mins1r) != (maxdr-mindr)) ||
  540.                       ((maxdc-mindc) != (maxs1c-mins1c))) {
  541.       error("Size of source and destination matrices don't match");
  542.       return;
  543.      }
  544.   erase_area(mindr, mindc, maxdr, maxdc);
  545.     if (mins1r == maxs1r && mins1c == maxs1c && mins2r == maxs2r &&
  546.         mins2c == maxs2c )  {
  547.         /* Source is a single cell */
  548.         for(vr = mindr; vr <= maxdr; vr++)
  549.             for (vc = mindc; vc <= maxdc; vc++)
  550.                submatrix(vr, vc, mins1r, mins1c, maxs1r, maxs1c,
  551.                                  mins2r, mins2c, maxs2r, maxs2c);
  552.     } else if (mins1r == maxs1r && mins2r == maxs2r) {
  553.         /* Source is a single row */
  554.         for (vr = mindr; vr <= maxdr; vr++)
  555.                submatrix(vr, mindc, mins1r, mins1c, maxs1r, maxs1c,
  556.                                  mins2r, mins2c, maxs2r, maxs2c);
  557.     } else if (mins1c == maxs1c && mins2c == maxs2c ) {
  558.         /* Source is a single column */
  559.         for (vc = mindc; vc <= maxdc; vc++)
  560.            submatrix(mindr, vc, mins1r, mins1c, maxs1r, maxs1c,
  561.                                  mins2r, mins2c, maxs2r, maxs2c);
  562.     } else {
  563.         /* Everything else */
  564.         submatrix(mindr, mindc, mins1r, mins1c, maxs1r, maxs1c,
  565.                                  mins2r, mins2c, maxs2r, maxs2c);
  566.     }
  567.  
  568. }
  569.  
  570. /***************************************************************************
  571.  *                                                                         *
  572.  *    Calculates Subtraction of two matrices.                              *
  573.  *                                                                         *
  574.  *                                     -Fang Wang  12/91                   *
  575.  ***************************************************************************/
  576.  
  577. /* Function now works 12-92 by Bob Parbs */
  578.  
  579. /* MAXSS no longer needed, similar changes as to addmatrix Bob Parbs 12-92 */
  580. /*#define MAXSS 2000*/
  581. void submatrix(vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c)
  582. /* void added Bob Parbs 12-92 */
  583. int vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c;
  584. {
  585.     register struct ent *p1,*p2;
  586.     register struct ent *n;
  587.     register int s1r, s1c, s2r, s2c;
  588.     register int dr, dc;
  589.     /*int i,j;*/                       /* no longer needed B.P. */
  590.     /*int list1[MAXSS],list2[MAXSS];*/ /* no longer needed B.P. */
  591.  
  592.     /* following loops to fill list1,list2 no longer needed Bob Parbs 12-92 */ 
  593.     /*for (i=0;i<=MAXSS;i++)
  594.         {
  595.             list1[i] = 0;
  596.             list2[i] = 0;
  597.         }
  598.     i = 0;
  599.     for (s1r=mins1r;s1r<=maxs1r;s1r++)
  600.         for (s1c=mins1c;s1c<=maxs1c;s1c++)
  601.             if ((p1 = *ATBL(tbl, s1r, s1c)) && p1->flags&is_valid)
  602.                    list1[i++] = p1->v;
  603.     j = 0;
  604.     for (s2r=mins2r;s2r<=maxs2r;s2r++)
  605.         for (s2c=mins2c;s2c<=maxs2c;s2c++)
  606.             if ((p2 = *ATBL(tbl, s2r, s2c)) && p2->flags&is_valid)
  607.                   list2[j++] = p2->v;
  608.     for (i=0;i<=MAXSS;i++)
  609.           list1[i] = list1[i] - list2[i];
  610.     i = 0;*/
  611.  
  612.     /* following loop modified to subtract entries as read Bob Parbs 12-92 */
  613.  
  614.     for (dr=vr, s1r=mins1r,s2r=mins2r; s1r<=maxs1r; s1r++,dr++,s2r++)
  615.        for (dc=vc, s1c=mins1c,s2c=mins2c; s1c<=maxs1c; s1c++, dc++,s2c++) {
  616.             n = lookat (dr, dc);
  617.             (void) clearent(n);
  618.             if ((p2 = *ATBL(tbl,s2r,s2c))&&(p2->flags&is_valid)){
  619.             if ((p1 = *ATBL(tbl, s1r, s1c)) && (p1->flags&is_valid))
  620.                 {
  621.                    copyent( n, p1, dr - s1r, dc - s1c);
  622.                    n->v = (p1->v-p2->v);
  623.                  }}
  624.             }
  625. }
  626. /***************************************************************************
  627.  *                                                                         *
  628.  *    Multiplication of two matrices.                                      *
  629.  *                                                                         *
  630.  *                                     -Fang Wang  12/91                   *
  631.  ***************************************************************************/
  632. /* TSSIZE moved to sc.h Bob Parbs 12-92*/
  633. /*#define TSSIZE 15*/
  634. void get_mult()     /* void added Bob Parbs 12-92 */
  635. {
  636.   char s[100];
  637.   struct m_range *findrge(),*rge_s1,*rge_s2,*rge_d;
  638.   struct ent *dmin,*dmax,*s1min,*s1max,*s2min,*s2max;
  639.   int mins1r, mins1c;
  640.   int maxs1r, maxs1c;
  641.   int mins2r, mins2c;
  642.   int maxs2r, maxs2c;
  643.   int mindr, mindc;
  644.   int maxdr, maxdc;
  645.   int vr, vc;
  646.   int r, c;
  647.  
  648.   sprintf(s,"1st matrix range:");
  649.   get_str(s,TSSIZE);
  650.   rge_s1 = findrge(s);
  651.   if (rge_s1 == NULL) {
  652.      error("Input syntax error");
  653.      return;
  654.   }
  655.   clearlines(0,0);
  656.   sprintf(s,"2nd matrix range:");
  657.   get_str(s,TSSIZE);
  658.   rge_s2 = findrge(s);
  659.   if (rge_s2 == NULL) {
  660.      error("Input syntax error");
  661.      return;
  662.   }
  663.   clearlines(0,0);
  664.   sprintf(s,"result matrix range:");
  665.   get_str(s,TSSIZE);
  666.   rge_d = findrge(s);
  667.   if (rge_d == NULL) {
  668.      error("Input syntax error");
  669.      return;
  670.   }
  671.   dmin=lookat(rge_d->sr,rge_d->sc);
  672.   dmax=lookat(rge_d->er,rge_d->ec);
  673.   s1min=lookat(rge_s1->sr,rge_s1->sc);
  674.   s1max=lookat(rge_s1->er,rge_s1->ec);
  675.   s2min=lookat(rge_s2->sr,rge_s2->sc);
  676.   s2max=lookat(rge_s2->er,rge_s2->ec);
  677.   mindr=dmin->row;
  678.   mindc=dmin->col;
  679.   maxdr=dmax->row;
  680.   maxdc=dmax->col;
  681.   if (mindr>maxdr) r = maxdr, maxdr = mindr, mindr = r;
  682.   if (mindc>maxdc) c = maxdc, maxdc = mindc, mindc = c;
  683.   maxs1r = s1max->row;
  684.   maxs1c = s1max->col;
  685.   mins1r = s1min->row;
  686.   mins1c = s1min->col;
  687.   maxs2r = s2max->row;
  688.   maxs2c = s2max->col;
  689.   mins2r = s2min->row;
  690.   mins2c = s2min->col;
  691.   if (mins1r>maxs1r) r = maxs1r, maxs1r = mins1r, mins1r = r;
  692.   if (mins1c>maxs1c) c = maxs1c, maxs1c = mins1c, mins1c = c;
  693.   if (mins2r>maxs2r) r = maxs2r, maxs2r = mins2r, mins2r = r;
  694.   if (mins2c>maxs2c) c = maxs2c, maxs2c = mins2c, mins2c = c;
  695.   /*if (maxdr >= MAXROWS  ||
  696.          maxdc >= MAXCOLS) {
  697.      error ("The table can't be any bigger");
  698.      return;
  699.   } */        /* commented out by Bob Parbs 12-92 */
  700.   if ((maxs1c-mins1c) != (maxs2r-mins2r))
  701.        {
  702.            error ("The size of two matrices doesn't match,cann't multply");
  703.            return;
  704.        }
  705.   if (((maxs1r-mins1r) != (maxdr-mindr)) ||
  706.                       ((maxdc-mindc) != (maxs2c-mins2c))) {
  707.       error("Size of source and destination matrices don't match");
  708.       return;
  709.      }
  710.   erase_area(mindr, mindc, maxdr, maxdc);
  711.     if (mins1r == maxs1r && mins1c == maxs1c && mins2r == maxs2r &&
  712.         mins2c == maxs2c )  {
  713.        /* Source is a single cell */
  714.         for(vr = mindr; vr <= maxdr; vr++)
  715.             for (vc = mindc; vc <= maxdc; vc++)
  716.               multmatrix(vr, vc, mins1r, mins1c, maxs1r, maxs1c,
  717.                                  mins2r, mins2c, maxs2r, maxs2c);
  718.     }
  719. /* else if ((mins2c==maxs2c) && (mins1r != maxs1r)) {
  720.          for (vr=mindr;vr<=maxdr;vc++)
  721.               multmatrix1(vr,mindc,mins1r,mins1c,maxs1r,maxs1c, 
  722.                                       mins2r,mins2c,maxs2r,maxs2c);
  723.     }
  724. */
  725.  else {
  726.         /* Everything else */
  727.         multmatrix(mindr, mindc, mins1r, mins1c, maxs1r, maxs1c,
  728.                                  mins2r, mins2c, maxs2r, maxs2c);
  729.     }
  730. }
  731.  
  732.  
  733. /*
  734. #define MINMAX 25
  735. multmatrix1 (vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c)
  736. int vr,vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c;
  737. {
  738.     register struct ent *p1,*p2;
  739.     register struct ent *n;
  740.     register int s1r, s1c, s2r, s2c;
  741.     register int dr, dc;
  742.     double sum;
  743.     int i,j,k;
  744.     double list1[MINMAX][MINMAX];
  745.     int list2[MINMAX];
  746.     int list3[MINMAX];
  747.  
  748.     for (i=0;i<MINMAX;i++)
  749.       {
  750.           list2[MINMAX] = 0;
  751.           for (j=0;j<MINMAX;j++)
  752.               list1[i][j] = 0;
  753.       }
  754.      i = 0;
  755.      for (s1r=mins1r;s1r<=maxs1r;s1r++)
  756.        {
  757.         j = 0;
  758.         for (s1c=mins1c;s1c<=maxs1c;s1c++)
  759.             {
  760.                if ((p1 = *ATBL(tbl, s1r, s1c)) && p1->flags&is_valid)
  761.                     list1[i][j++] = p1->v;
  762.             }
  763.         i++;
  764.        }
  765.      j = 0;
  766.      for (s2r=mins2r;s2r<=maxs2r;s2r++)
  767.             if ((p2 = *ATBL(tbl, s2r, mins2c)) && p2->flags&is_valid)
  768.                   list2[j++] = p2->v;
  769.      for (i=0;i<MINMAX;i++)
  770.         {
  771.             sum = 0;
  772.             for (k=0;k<MINMAX;k++)
  773.                sum = sum + list1[i][k] * list2[k];
  774.             list3[i++] = sum;
  775.         }
  776.      i = 0;
  777.      for (dr=vr, s1r=mins1r; s1r<=maxs1r; s1r++,dr++)
  778.          {
  779.              n = lookat (dr, vc);
  780.             (void) clearent(n);
  781.             if ((p1 = *ATBL(tbl, s1r, mins1c)) && (p1->flags&is_valid))
  782.                 {
  783.                    copyent( n, p1, dr - s1r, dc - s1c);
  784.                    n->v = list3[i++];
  785.                  }
  786.        }
  787. }
  788.  
  789.  
  790. */
  791. /***************************************************************************
  792.  *                                                                         *
  793.  *    Calcultes Multiplication of two matrices.                            *
  794.  *                                                                         *
  795.  *                                     -Fang Wang  12/91                   *
  796.  ***************************************************************************/
  797. /* MINMAX moved to sc.h Bob Parbs 12-92 */
  798. /*#define MINMAX 25*/
  799. void multmatrix(vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c)
  800. /* void added Bob Parbs 12-92 */
  801. int vr, vc, mins1r, mins1c, maxs1r, maxs1c,mins2r,mins2c,maxs2r,maxs2c;
  802. {
  803.     register struct ent *p1,*p2;
  804.     register struct ent *n;
  805.     register int s1r, s1c, s2r, s2c;
  806.     register int dr, dc;
  807.     double sum;
  808.     int i,j,k;
  809.     double list1[MINMAX][MINMAX];
  810.     double list2[MINMAX][MINMAX];
  811.     double list3[MINMAX][MINMAX];
  812.  
  813.      for (i=0;i<MINMAX;i++)
  814.        for (j=0;j<MINMAX;j++)
  815.         {
  816.             list1[i][j] = 0;
  817.             list2[i][j] = 0;
  818.             list3[i][j] = 0;
  819.         }
  820.      i = 0;
  821.      for (s1r=mins1r;s1r<=maxs1r;s1r++)
  822.        {
  823.         j = 0;
  824.         for (s1c=mins1c;s1c<=maxs1c;s1c++) 
  825.                if ((p1 = *ATBL(tbl, s1r, s1c)) && p1->flags&is_valid)
  826.                     list1[i][j++] = p1->v;
  827.         i++;
  828.        }
  829.           
  830.      i = 0;
  831.      for (s2r=mins2r;s2r<=maxs2r;s2r++)
  832.        {
  833.          j = 0;
  834.          for (s2c=mins2c;s2c<=maxs2c;s2c++)
  835.             if ((p2 = *ATBL(tbl, s2r, s2c)) && p2->flags&is_valid)
  836.                   list2[i][j++] = p2->v;
  837.          i++;
  838.        }
  839.      for (i=0;i<MINMAX;i++)
  840.            for (j=0;j<MINMAX;j++)
  841.               {
  842.                  sum = 0;
  843.                  for (k=0;k<MINMAX;k++)
  844.                      sum = sum + (list1[i][k]) * (list2[k][j]);
  845.                  list3[i][j] = sum;
  846.                }
  847.      i = 0;
  848.      for (dr=vr, s1r=mins1r; s1r<=maxs1r; s1r++,dr++)
  849.        {
  850.           j = 0;
  851.           for (dc=vc, s1c=mins2c; s1c<=maxs2c; s1c++, dc++) {
  852.             n = lookat (dr, dc);
  853.             (void) clearent(n);
  854.             if ((p1 = *ATBL(tbl, s1r, s1c)) && (p1->flags&is_valid))
  855.                 {
  856.                    copyent( n, p1, dr - s1r, dc - s1c);
  857.                    n->v = list3[i][j++];
  858.                  }
  859.             }
  860.            i++;
  861.        }
  862. }
  863.  
  864.  
  865. /***************************************************************************
  866.  *                                                                         *
  867.  *    Invert the matrix.                                                    *
  868.  *                                                                         *
  869.  *                                     -Fang Wang  12/91                   *
  870.  ***************************************************************************/
  871. /* REG_LEN moved to sc.h Bob Parbs 12-92 */
  872. /*#define REG_LEN 28*/
  873. void get_invert()     /* void added Bob Parbs 12-92 */
  874. {
  875.   char s[100];
  876.   struct m_range_sd *find_rge();
  877.   struct ent *dv1,*dv2,*v1,*v2;
  878.   int minsr, minsc;
  879.   int maxsr, maxsc;
  880.   int mindr, mindc;
  881.   int maxdr, maxdc;
  882.   int vr, vc;
  883.   int r, c;
  884.  
  885.  
  886.   sprintf(s, "invert [dest_range src_range] ");
  887.   get_str(s,REG_LEN);
  888.   rge_sd=find_rge(s);
  889.   if (rge_sd == NULL) {
  890.       error("Input syntax error");
  891.       return;
  892.   }
  893.  
  894. /* FIXME-real stuff (use this, or something close...:-)
  895.         maxr = e->e.o.right->e.r.right.vp -> row;
  896.         maxc = e->e.o.right->e.r.right.vp -> col;
  897.         minr = e->e.o.right->e.r.left.vp -> row;
  898.         minc = e->e.o.right->e.r.left.vp -> col;
  899.         if (minr>maxr) r = maxr, maxr = minr, minr = r;
  900.         if (minc>maxc) c = maxc, maxc = minc, minc = c;
  901. */
  902.   dv1=lookat(rge_sd->dsr,rge_sd->dsc);
  903.   dv2=lookat(rge_sd->der,rge_sd->dec);
  904.   v1=lookat(rge_sd->ssr,rge_sd->ssc);
  905.   v2=lookat(rge_sd->ser,rge_sd->sec);
  906.   mindr = dv1->row;
  907.   mindc = dv1->col;
  908.   maxdr = dv2->row;
  909.   maxdc = dv2->col;
  910.   if (mindr>maxdr)
  911.   {    r = maxdr, maxdr = mindr, mindr = r;
  912.   }
  913.   if (mindc>maxdc)
  914.   {    c = maxdc, maxdc = mindc, mindc = c;
  915.   }
  916.   maxsr = v2->row;
  917.   maxsc = v2->col;
  918.   minsr = v1->row;
  919.   minsc = v1->col;
  920.   if (minsr>maxsr) r = maxsr, maxsr = minsr, minsr = r;
  921.   if (minsc>maxsc) c = maxsc, maxsc = minsc, minsc = c;
  922.   /*if (maxdr >= MAXROWS  ||
  923.          maxdc >= MAXCOLS) {
  924.      error ("The table can't be any bigger");
  925.      return;
  926.   }*/   /* commented out by Bob Parbs 12-92 */
  927.   if (((maxsr-minsr) != (maxdr-mindr)) ||
  928.                       ((maxdc-mindc) != (maxsc-minsc))) {
  929.       error("Size of source and destination matrices don't match");
  930.       return;
  931.      }
  932.   erase_area(mindr, mindc, maxdr, maxdc);
  933.   if (minsr == maxsr && minsc == maxsc) {
  934.         /* Source is a single cell */
  935.         for(vr = mindr; vr <= maxdr; vr++)
  936.             for (vc = mindc; vc <= maxdc; vc++)
  937.                invertmatrix(vr, vc, minsr, minsc, maxsr, maxsc);
  938.    } else {
  939.         /* Everything else */
  940.         invertmatrix(mindr, mindc, minsr, minsc, maxsr, maxsc);
  941.    }
  942. }
  943.  
  944. /***************************************************************************
  945.  *                                                                         *
  946.  *    Calcultes the inversion of the matrix.                               *
  947.  *                                                                         *
  948.  *                                     -Fang Wang  12/91                   *
  949.  ***************************************************************************/
  950. /* MAXROW, MAXCOL moved to sc.h Bob Parbs 12-92 */
  951. /*#define MAXROW 30*/
  952. /*#define MAXCOL 30*/
  953. void invertmatrix(vr, vc, minsr, minsc, maxsr, maxsc)/* void added Bob Parbs*/
  954. int vr, vc, minsr, minsc, maxsr, maxsc;
  955. {
  956.     register struct ent *p;
  957.     register struct ent *q;
  958.     register int sr, sc;
  959.     register int dr, dc;
  960.     double list[MAXROW][MAXCOL];
  961.     /* changed from MAXROWS, MAXCOLS B.P. */
  962.     int i,j,k,m,n;
  963.     int rowlim,collim;
  964.     double temp;
  965.    
  966.     for (i=0; i<((maxsr-minsr)*2+1); i++)
  967.       for (j=0; j<((maxsc-minsc)*2+1); j++)
  968.           list[i][j] = 0;
  969.     rowlim = maxsr-minsr+1;
  970.     collim = maxsc-minsc+1;
  971.     for (i=0;i<rowlim;i++)
  972.        for (j=0;j<collim;j++)
  973.           if (i==j)  list[i][j] = 1;
  974.  
  975.     for (i=0,sr=minsr;(i<rowlim) && (sr<=maxsr); i++,sr++)
  976.        for (j=collim,sc=minsc;(j<(2*collim)) && (sc<=maxsc); j++,sc++)
  977.            if ((p = *ATBL(tbl, sr, sc)) && p->flags&is_valid)
  978.                 list[i][j] = p->v;
  979.     for (j=collim; j<(2*collim); j++)  {
  980.         k = j-collim;
  981.         temp = list[k][j];
  982.         for (i=0; i<(2*collim); i++)
  983.             list[k][i] = list[k][i] / temp;
  984.         for (m=0; m < rowlim; m++)
  985.             for (n=0; n<(2*collim); n++)
  986.                if (( m != k ) && ( n != j )) 
  987.                   list[m][n] = list[m][n]-list[k][n]*list[m][j];
  988.     }
  989.     i = 0;
  990.     for (dr=vr, sr=minsr; sr<=maxsr; sr++,dr++)
  991.        {
  992.           j = 0;
  993.           for (dc=vc, sc=minsc; sc<=maxsc; sc++, dc++) {
  994.             q = lookat (dr, dc);
  995.             (void) clearent(q);
  996.             if ((p = *ATBL(tbl, sr, sc)) && (p->flags&is_valid))
  997.                 {
  998.                    copyent( q, p, dr - sr, dc - sc);
  999.                    q->v = list[i][j++];
  1000.                  }
  1001.             }
  1002.            i++;
  1003.        }
  1004. }
  1005. /*#endif*/
  1006.