🚀 go-pugleaf

In article <1debc4INNieg@chnews.intel.com>, bhoughto@sedona.intel.com
(Blair P. Houghton) writes:
|> In article <1992Nov5.203939.1323@fcom.cc.utah.edu>
tim@osiris.usi.utah.edu (Tim Burns 581-4439) writes:
|> >memory dynamically.  Right now, when I allocate my array using the 
|> >standard array allocation:  double A[L][M], where L and M are constants,
|> 
|> What you see is that `A' has a type compatible with `(double *)',
|> whereas what the _Numerical_Recipes_ method does is create
|> `m' as compatible with `(double **)'.
|> 
|> All you need to do is allocate enough space for the
|> two-dimensional array.  C's array-memory mapping is flat,
|> in row-major order.
|> 
|> You want L rows of M columns of doubles, so you need
|> 
|> 	m = (double *) malloc ( L * M * sizeof(double) );
|> 
|> and now `m' is compatible with `A'.
|> 
|> Accesses to `m' can now be made using C's array-access syntax;
|> That is,
|> 
|> 	int row, col;
|> 	...
|> 
|> 	m[row][col]
|> 
|> gives the number at row and col.
|> 
|> 	m[row][col+1]
|> 
|> gives the next number in `m', and
|> 
|>         m[row+1][col]
|> 
|> gives the number in the next row, i.e., L elements away from
|> the number in this row of `m'.
|> 
|> 				--Blair
|> 				  "Isn't this just a little basic?"

Haven't we seen this kind of wrong explanation only few weeks ago in
comp.lang.c?
How shall the poor compiler know, after defining

	double **m;

that m[x][y] means an element, which is x*M+y elements away from the
origin of m?  What you need is either to declare

	double (*m) [M];

which doesn't give you the freedom to have variable dimensions except
for L, or

	double *m;
	# define access(matrix,x,y,dim) ((matrix) [(x) * (dim) + (y)])

which has to be used like:

	m = malloc (L * M * sizeof (double));

	... access (m, x, y, M) ...

Of course, you may want to ``hide'' ``m'' and ``M'' inside access.
In ANSI C you can write

	# define m(x,y) (m[(x) * M + (y)])

because the ANSI C preprocessor will not go into a recursion on m.
With this kludge you can use ``m'' almost like ever:

	... m (x, y) ...

instead of
	... m [x][y]

Enjoy!
-Matthias