# Should i use lookup-lists instead of a lot of multiplication?

in my application I have a very large array of bytes, its a flattened 3 dimensional array, we populate the array using 3 nested for loops (x, y, z) and then we get the values we want by using a little bit of math, most specifically:

To get an index in the array:

```return x + z*SizeX + y*SizeX*SizeZ;
```

and to return the x/y/z coordinates, given an index:

```int index = pos;
var y = (ushort) (pos/SizeX/SizeZ);
pos -= y*SizeX*SizeZ;
var z = (ushort) (pos/SizeX);
pos -= z*SizeX;
var x = (ushort) pos;

return new BlockPos(x, y, z, index, this);
```

First off, I would imagine the second one can be made more efficient, i just don't know how to do it, any help there would be appreciated :P

My main quesion is, would it be faster for me to make a lookup table for the y and x values (populating when the class is loaded) or is it faster to just leave the multiplication in there?

edit This math is called a LOT in some cases, so if it would be faster, even for a longer startup it would make a differance better.

In most languages and architectures, multiplication will become one (or a few) machine instructions. Whilst those instructions may be relatively expensive, they should still be cheaper that performing a lookup operation - and a lookup operation may very well require a multiplication anyway.

E.g. "locate the 4th element of the array" will be

```<array base address> + (3 * <array element size>)
```

The only optimization I'd recommend given your pseudo code is to perform the "constant" operations (e.g. SizeX*SizeZ) once, and store those results.