# 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.

## Answers

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.