Redim Array with multiple elements

[dragonjim]

I'm working on a program with an ever expanding number of records and, rather than create a massive array first off, I decided to use Redim() to steadily increase the size of the array as it was required.

This worked fine for single element arrays - but when I tried it with arrays of more than one element, I got some interesting results as, it turns out, GFA expands the first element rather than the last element first. I'll explain:

The array is a%(2,2) and you fill each element with the value of the first element: e.g. a%(1,1) =1, a%(1,2) = 1, a%(2,1) =2, a%(2,2) =2. If you Redim the array: Redim a%(4,2) for example, the original values of a%(1,1) ... a%(2,2) have been changed as can be seen from this small program below:

OpenW 1
Dim a%(2, 2)
Local m, n
For n = 1 To 2
a%(n, 1) = n : a%(n, 2) = n
Next n
Print "Before Redim:"
For n = 1 To 2 : For m = 1 To 2
Print AT(m * 14, n + 1); "a%("; n; ","; m; ") = "; a%(n, m)
Next m : Next n
ReDim a%(4, 2)
Print : Print "After Redim:"
For n = 1 To 4 : For m = 1 To 2
Print AT(m * 14, n + 5); "a%("; n; ","; m; ") = "; a%(n, m)
Next m : Next n
While MouseK = 0 : Wend
CloseW 1

So what I did instead was create my own little subroutine with an array counter arr_ct% (to alert the program when it is reaching the array limit - I suppose I could have used UBound) for an array arr%(), which appears below as 'Sub Increase_Array(Byref ct)' with accompanying programming to show it works (hopefully!).

OpenW Full 1
Global Dim arr%(10, 10)
Global Dim arr_ct% = 10
Local act% = 0
arr%(1, 1) = 1 : arr%(10, 10) = 10
Print "act%", "UBound(arr%())", "arr%(1,1)", "arr%(10,10)"
Print
Repeat
Increase_Array(act%)
Print act%, UBound(arr%()), arr%(1, 1), arr%(10, 10)
Until act% = 30
While MouseK = 0 : Wend
CloseW 1

Sub Increase_Array(ByRef ct%)
Local n, m
Inc ct%
If ct% > arr_ct%
Dim nw_arr%(arr_ct% + 10, 10)
For n = 1 To 10 : For m = 1 To 10
nw_arr%(n, m) = arr%(n, m)
Next m : Next n
Swap arr%(), nw_arr%()
Add arr_ct%, 10
EndIf
EndSub

Interestingly, although the help file says that Swap can only be used with similar sized arrays, it works perfectly in this situation. (I did trying ReDim-ing arr%() and then re-populating but this was about three times slower and the alternative was quicker to write!)

My questions, as this is the 'Help' section, are:

1. Have I misunderstood ReDim and is there, in fact, a method of using it to get the results I need?

and, if not...

2. Can you suggest any improvements to the above that will make it run quicker? You'll notice I've incremented the array by 10 each time to prevent too much drag on the rest of the program.

[649psoft2]

I haven't thourghly checked your code here but I have had problems with Erase and Redim with large arrays in the past. There is the global/local memory not being cleaned up problem as with your previous example.

I think that although Redim appears to preserve the data in a single element array it does not reorganize the raw memory locations in a multidimentional Array.

In general always make a copy of the array and after it has been ReDim 'ed copy it back to the original array, and delete the temproary copy.

This is what you are doing with Swap.

Since it is easy to make an error with ReDim that could become unstable
with very large arrays I now use API buffers instead of GB32 Array/Redim
where it is important.

This instablity I had to learn the hard and costly way it is a difficult to pin
down some programmers have not found it but the original documentation
mentions this back when 2.3 was released.

I think they wanted to be compatable to 16 bit conversion and earlier versions
so the used a Compiler that did not always use the Windows API Memory Allocation
Functions. The API rather than malloc they may have used at the time has additional checking for multitasking pointers for the 32 bit memory model when sharing physical memory.

[649psoft2]

About improvements:

Swap is about as fast as you can get since it swaps pointers but you might have to test for the possiblities in a multidimentional array.

For the method of copying back to the redimmed array from a temproary array
Bmove is about the fastest but for a time it acted only on the 16 bit memory
model so was restricted to max 64 kb chunks.

MemCopy and MemMove are fast but I think there is one typo in the Source, Dest
ordering in the documentation.

[649psoft2]

If you wat to speed optimize the code the 16 bit word or a& variable is the fastest
for the for next loops.

[dragonjim]

Thanks for all those replies...there are some useful ideas in them.

Looking through the help files, BlockMove looks a handy utility for mass transfer as well (looking further, it does say its the same as MemMove, so I feel this justs proves your point!).

Probably not a good idea to look too closely at the programming as there a number of stupid mistakes - my only excuse: it was written quickly as an example. For example, if you wish to use this type of example in your code, you would need to change the For n=1 to 10 statement to either: For n=1 to arr_ct% or For n=1 to UBound(arr%()), otherwise you'll never copy the data from more than the first ten records!

As to how ReDim works, it appears to be a mystery...if Option Base 0 is used with my example, the new array shows the original values for the records of the first elements shifted up to the next record, while the second elements have been blanked. If Option Base 1 is used, then all records are reset to zero. I remain confused and will continue to use my alternative.

Finally, your comment on the For...Next loop is pertinent and something I should have remembered from my Atari days. Sadly, the grey cells holding that particular info have obviously gone into retirement!

[dragonjim]

Just another quick note...looking in the help file concerning ReDim, it says that it does not work with variant arrays (whether this is arrays within variant arrays or simply the parent array itself is not altogether clear).

I have set up a couple of quick tests and it looks like the 'ReDim' substitute array above actually does work with variants.

So, hopefully, this is another use for it.