home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 September / Simtel20_Sept92.cdr / msdos / ddjmag / ddj8908.arc / ANDERSON.LST next >
File List  |  1989-07-06  |  4KB  |  174 lines
  1. C MULTIDIMENSIONAL ARRAYS AT RUN TIME
  2. by Paul Anderson
  3.  
  4.  
  5. [LISTING ONE]
  6.  
  7.  
  8. #include <stdio.h>
  9. #include <malloc.h>
  10.  
  11. char **dim2(row, col, size)          /* creates 2D array */
  12. int row, col;
  13. unsigned size;
  14. {
  15.    int i;
  16.    char **prow, *pdata;
  17.  
  18.    pdata = (char *) calloc(row * col, size);
  19.    if (pdata == (char *) NULL) {
  20.       fprintf(stderr, "No heap space for data\n");
  21.       exit(1);
  22.    }
  23.    prow  = (char **) malloc(row * sizeof (char *));
  24.    if (prow == (char **) NULL) {
  25.       fprintf(stderr, "No heap space for row pointers\n");
  26.       exit(1);
  27.    }
  28.  
  29.    for (i = 0; i < row; i++) {
  30.      prow[i] = pdata;             /* store pointers to rows */
  31.      pdata += size * col;         /* move to next row */
  32.    }
  33.    return prow;                   /* pointer to 2D array */
  34. }
  35.  
  36. void free2(pa)                   /* frees 2D heap storage */
  37. char **pa;
  38. {
  39.    free(*pa);                    /* free the data */
  40.    free(pa);                     /* free pointer to row pointers */
  41. }
  42.  
  43.  
  44. [LISTING TWO]
  45.  
  46.  
  47. #include <stdio.h>
  48. #include <malloc.h>
  49.  
  50. char ***dim3(grid, row, col, size)            /* creates 3D array */
  51. int grid, row, col;
  52. unsigned size;
  53. {
  54.    int i;
  55.    char ***pgrid, **prow, *pdata;
  56.  
  57.    pdata = (char *) calloc(grid * row * col, size);
  58.    if (pdata == (char *) NULL) {
  59.       fprintf(stderr, "No heap space for data\n");
  60.       exit(1);
  61.    }
  62.    prow  = (char **) malloc(grid * row * sizeof (char *));
  63.    if (prow == (char **) NULL) {
  64.       fprintf(stderr, "No heap space for row pointers\n");
  65.       exit(1);
  66.    }
  67.    pgrid  = (char ***) malloc(grid * sizeof (char **));
  68.    if (pgrid == (char ***) NULL) {
  69.       fprintf(stderr, "No heap space for grid pointers\n");
  70.       exit(1);
  71.    }
  72.  
  73.    for (i = 0; i < grid * row; i++) {
  74.      prow[i] = pdata;                    /* store pointers to rows */
  75.      pdata += col * size;                /* move to next row */
  76.    }
  77.  
  78.    for (i = 0; i < grid; i++) {
  79.      pgrid[i] = prow;                    /* store pointers to grid */
  80.      prow += row;                        /* move to next grid */
  81.    }
  82.    return pgrid;                         /* pointer to 3D array */
  83. }
  84.  
  85. void free3(pa)                          /* frees 3D heap storage */
  86. char ***pa;
  87. {
  88.    free(**pa);                  /* free the data */
  89.    free(*pa);                   /* free the row pointers */
  90.    free(pa);                    /* free the grid pointers */
  91. }
  92.  
  93.  
  94. [LISTING THREE]
  95.  
  96.  
  97. /* det.c - find determinant of a two-dimensional array of doubles */
  98.  
  99. #include <stdio.h>
  100. #include <malloc.h>
  101.  
  102. main()
  103. {
  104.     double det();
  105.  
  106.     static double f[4][4] = {
  107.         1, 3, 2, 1,
  108.         4, 6, 1, 2,
  109.         2, 1, 2, 3,
  110.         1, 2, 4, 1
  111.     };
  112.     static double g[5][5] = {
  113.         1, 3, 2, 1, 7,
  114.         4, 6, 1, 2, 6,
  115.         2, 1, 2, 3, 5,
  116.         1, 2, 4, 1, 4,
  117.         8, 5, 4, 1, 3
  118.     };
  119.  
  120.     printf ("determinant of f = %g\n", det(f, 4));
  121.     printf ("determinant of g = %g\n", det(g, 5));
  122. }
  123.  
  124. double det(arg, n)      /* calculate determinant for n by n matrix */
  125. char *arg;
  126. int n;
  127. {
  128.     register int i, j, k;
  129.     double **a;          /* this is the array name */
  130.     char **sdim2();
  131.     double ret;          /* determinant */
  132.     double x;            /* temp */
  133.  
  134.     /* dynamically create 2 dimensional "array" a from arg */
  135.     a = (double **) sdim2(arg, n, n, sizeof(double));
  136.  
  137.     /* determinant algorithm using rows and columns */
  138.     for (k = 0; k < n - 1; k++)
  139.         for (i = k + 1; i < n; i++){
  140.             x = a[i][k]/a[k][k];
  141.             for (j = k; j < n; j++)
  142.                 a[i][j] = a[i][j] - x * a[k][j];
  143.             }
  144.  
  145.     for (ret = 1, i = 0; i < n; i++)
  146.         ret *= a[i][i];
  147.  
  148.     free(a);               /* free heap storage */
  149.  
  150.     return ret;
  151. }
  152.  
  153. char **sdim2(pdata, row, col, size)          /* "creates" 2D array */
  154. char *pdata;
  155. int row, col;
  156. unsigned size;
  157. {
  158.    int i;
  159.    register char **prow;
  160.  
  161.    prow  = (char **) malloc(row * sizeof (char *));
  162.    if (prow == (char **) NULL) {
  163.       fprintf(stderr, "No heap space for row pointers\n");
  164.       exit(1);
  165.    }
  166.  
  167.    for (i = 0; i < row; i++) {
  168.      prow[i] = pdata;             /* store pointers to rows */
  169.      pdata += size * col;         /* move to next row */
  170.    }
  171.    return prow;                   /* pointer to 2D array */
  172. }
  173.  
  174.