I have a program that needs to create an array of arbitrary dimension. In other words, if you pass 2 to a routine, that routine has to allocate a 2 dimensional array.

So I wrote a routine to do this. Lets assume for simplicity that every dimension has the same number of values. And lets suppose that if we want to get a value out of this array, we pass the indices as an array too.

So for example, if we have a 3 dimensional array, and we want to access array(3,2,7) we pass an one dimensional array that has 3,2,and 7 in it.

I've found a way to do this, but it requires a lot of multiplications to find the index. So I thought of an alternative, which is this:

Select Case n
Case 1
dim ArrayN(0) as integer
Case 2
dim ArrayN(0)(0) as integer
Case 3
dim ArrayN(0)(0)(0) as integer
Case Else
MsgBox "dimension is too high", vbCritical
End Select

It would seem to me that this kind of array operates by addition, rather than multiplication.

Internally if you searched for arrayN(4)(2)(5) the compiler would add 4 to the first index,

which would give you an array to which you add 2, which would give you an array to which you add 5.

Now at most, I have 5 dimensional arrays, but I wonder if this kind of array means a lot of

internal pointers in vb.net, and may exceed the capacity of vb.net to hold pointers. For instance,

If the size of each dimension is 10, then an array of 2 dimensions has 10 pointers, an array of

3 dimensions has 100 pointers, an array of 5 dimensions has 10,000 pointers.

And I might have several such arrays in memory at the same time.

There seems to be a tradeoff in programming often between speed and space.

The alternative method (that used the multiplications) was to create a one dimensional array that I

would do computations to treat as a multi-dimensional array:

Function GetIndex(ByVal Arrayofindices() As Integer) As Integer
Dim theIndex As Integer
theIndex = Arrayofindices(0)
For k = 1 To Arrayofindices.GetLength(0) - 1
theIndex = ArrayofMFindices(k) + theIndex * DimensionSize
Next
Return (theIndex)
End Function

so for N dimensions, you have N-1 multiplications just to get at a weight.

Perhaps this is true of regular arrays internally too, e.g. MyArr(5,7,2)
Still, if anyone knows a better method, one that does not overload vb.net's

capacity to hold pointers, and that does not take up too much space, and that

does not require lots of multiplications just to get a value, let me know!

Thanks,

Gideon