C# array question (split)

Question

Question very simple - say, i got function, which receives array as its arguments

void calc(double[] data)

how do "split" this data in two subarrays and pass to sub functions like this

calc_sub(data(0, length/2));
cals_sub(data(length /2, length /2));

i hope, you got the idea - in c++ i would write this

void calc(double * data, int len)
{
   calc_sub(data, len / 2); //this one modifies data!!
   calc_sub(data + len / 2, len / 2); //this one modifies data too!!
}

How to do same in C# without unecesary memory copying? I would need 2 memory copies here. 1) from data to splitted data 2) calc_sub 3) from splitted data back to data! This is huge waste of time and memory!

Answer 1

The short answer is that to get a subarray, you'd have to create a new array and copy elements... Or if you were using c++, you'd be memcpying.

Now, why not just take the offset/count approach? When calling calc_sub(blargh[] array), instead use calc_sub(blargh[] array, int offset, int count)?

This is basically the c# way of passing a pointer to the start/half-pos element and telling the function to work on only half the array's elements.

---

I should note that unless you're working with huge double arrays, you really shouldn't be worrying about this. 64 bits = 8 bytes. Even if you had an array of 1000 elements, that's 8000 bytes, ~8 kB of memory, which you will pretty much free in less than a second...

Now, it's always a good idea to conserve memory where possible, but I'd rule this as premature optimization.

I should also note that arrays are passed by reference, as they are really objects, as opposed to ints or strings, so this method is the best memory-wise [it doesn't copy the array; it gives something like a pointer to the array object], but it's limited in that modifying the array in your function will modify the array passed outside of your function call.

Answer 2

The easiest is probably using LINQs Take and Skip extension methods:

int half = data.Length / 2;
double[] sub1 = data.Take(half).ToArray();
double[] sub2 = data.Skip(half).ToArray();

Answer 3

Depending on what calc_sub does, you can make a IEnumerable class which takes the array and iterates over some part of the array. Something like ArraySegment, but better.

Answer 4

Go ahead and write your own subarray function like this:

public static class ArrayExtensions
{
  T[] SubArray<T>(this T[] arr, int startIndex,int count)
  {
    var sub = new T[count];
    Array.Copy(arr,startIndex,sub,o,count);
    return sub;
  }
}

and then you can use it like:

void calc(double[] data)
{
  var half = data.Length /2;
  data.SubArray(0, half ));
  data.SubArray(half , half ));
}

Answer 5

If you can make the calc_sub method take an IEnumerable<double> instead of a double[], you can use extension methods to create expressions that return part of the array:

void calc(double[] data) {
  int half = data.Length / 2;
  calc_sub(data.Take((half));
  calc_sub(data.Skip(half));
}

This way you don't have to copy the data to new arrays, the expressions will return items from the original array.