Vista - Fast copy method of sub array (=array range) possible?

Assume I want to copy the sub-array with the slots 234 until 789 from arrayone
to the end of arraytwo I can do this step by step with

ind = 234
do until (ind = 790)
arraytwo.Add arrayone(ind)
ind = ind + 1
Loop

But this can be rather inefficient.
I could imagine that there is a faster way with copying a whole sub array at once.
Somethig similar to:

arraytwo.Add arrayone.getSubArray(234,789)

The same question arises for delete operation.

Thomas

Thomas Lebrecht wrote:Why? Somewhere something has to do the loop, be it in your code or the code
generated from your code.

Maybe it's just your preference to use a do...loop, but do you think a
for...next loop would be neater?

And are you talking about arrays or arraylists? The help for my VS2008 says
that Array.Add always throws an exception because Arrays are of fixed size
and so cannot be added to.

ArrayList.AddRange and ArrayList.GetRange appear to be what you want.
ArrayList.RemoveRange

Also, depending on your version of VS, you might want to consider using a
List(Of <type>) because they are more efficient as the computer "knows" in
advance what sort of object it is dealing with in the List.

HTH

Andrew

My reply doesn't seem to have propagated correctly, so I'm posting it again
through a different news server...

Thomas Lebrecht wrote:Why? Somewhere something has to do the loop, be it in your code or the code
generated from your code.

Maybe it's just your preference to use a do...loop, but do you think a
for...next loop would be neater?

And are you talking about arrays or arraylists? The help for my VS2008 says
that Array.Add always throws an exception because Arrays are of fixed size
and so cannot be added to.

ArrayList.AddRange and ArrayList.GetRange appear to be what you want.
ArrayList.RemoveRange

Also, depending on your version of VS, you might want to consider using a
List(Of <type>) because they are more efficient as the computer "knows" in
advance what sort of object it is dealing with in the List.

HTH

Andrew

Thomas,

What do you call inefficient, 3 picoseconds or 5 picoseconds?

Don't take to much time with these kind of methods. For sure takes one move
on the screen from your form 100 times more time.

Although the For index is more common currently.

Cor


"Thomas Lebrecht" <t.lebrecht@xxxxxx> wrote in message
news:49c2071e$0$32669$9b4e6d93@xxxxxx-online.net...

"Thomas Lebrecht" <t.lebrecht@xxxxxx> wrote in message
news:49c2071e$0$32669$9b4e6d93@xxxxxx-online.net...The OP's question is entirely reasonable. From a computing-time point of
view it is usually much more efficient to deal with the elements of an array
with compiled and optimized code than on an element-by-element basis at the
source language level. Depending on the array size, we're not talking about
picoseconds as Core Lightert suggests but about milliseconds. That's one
million times longer!

The following example illustrates the principle. It consists of three
components:
1. Populate an array of 100,000 elements with random numbers.
2. Copy this array as a whole to a second array and report the time it
takes.
3. Copy this array on an element-by-element basis to a third array and
report the time it takes.

On my machine the element-by-element copy takes 16 times longer than the
direct copy. This is a huge improvement that no programmer should ignore.
Unfortunately I am not aware of how Step 2 above can be performed on a
sub-array.

const size = 100000
ReDim a1(size)
ReDim a3(size)

For i = 0 To UBound(a1)
a1(i) = Rnd
Next

t = Timer
a2 = a1
WScript.Echo "Elapsed time=" & (Timer - t) * 1000 & " ms"

t = Timer
For i = 0 To UBound(a1)
a3(i) = a1(i)
Next
WScript.Echo "Elapsed time=" & (Timer - t) * 1000 & " ms"

"Thomas Lebrecht" <t.lebrecht@xxxxxx> schrieb:Are you actually using arrays or a collection/list type?

Just take a look at 'Array.Copy', 'Array.CopyTo' and maybe
'Buffer.BlockCopy' if you are dealing with arrays.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>

"Thomas Lebrecht" <t.lebrecht@xxxxxx> wrote in message
news:49c2071e$0$32669$9b4e6d93@xxxxxx-online.net...In the Array class, one of the methods is:
Public Shared Sub Copy ( _
sourceArray As Array, _
sourceIndex As Long, _
destinationArray As Array, _
destinationIndex As Long, _
length As Long _
)

Visual Basic (Usage)
Dim sourceArray As Array
Dim sourceIndex As Long
Dim destinationArray As Array
Dim destinationIndex As Long
Dim length As Long

Array.Copy(sourceArray, sourceIndex, _
destinationArray, destinationIndex, _
length)

this will do what you want.