🚀 go-pugleaf

From article <SLEHAR.92Aug7111245@kendall.bu.edu>, by slehar@kendall.bu.edu (Steve Lehar):
> 
> God forbid you should have to make any changes  to this  code!  I have
> tried to think of some kind of macro that would simplify things a bit,
> but I can't come up with anything  that is less  complicated than what
> you see here.  Does anyone have an elegant solution to this problem?
> 

This is what I use when I have to access the contents of an image on a 
pixel-to-pixel basis:

function (DATATYPE *data, int xsize, int ysize)
{
  int x, y;
#define PIX(a,b) ((a)+(b)*xsize)

  for (y = 0; y < ysize; y++)
    for (x = 0; x < xsize; x++)
      data[PIX(x,y)] = ...

}

this to me looks a little better than having the arithmetics explicitly 
plugged into the square brackets.  You could even use this macro:

function (DATATYPE *data, int xsize, int ysize)
{
  int x, y;
#define DATA(a,b) data[((a)+(b)*xsize)]

  for (y = 0; y < ysize; y++)
    for (x = 0; x < xsize; x++)
      DATA(x,y) = ...

}


A far as making the loop tight and fast, if you are only accessing your data
in a sequential way, the best thing to do is increment the pointer as in:


function (DATATYPE *data, int xsize, int ysize)
{
  int x, y;
  DATATYPE *dp;

  dp = data;
  for (y = 0; y < ysize; y++)
    for (x = 0; x < xsize; x++, dp++)
      *dp = ...

}

Inner loops can be written in a similar fashion.  As far as I know, this
will be as fast as you can get.

Hope this helps