I'm trying to figure out how to get a single dimension from a multidimensional array (for the sake of argument, let's say it's 2D), I have a multidimensional array:
double[,] d = new double[,] { { 1, 2, 3, 4, 5 }, { 5, 4, 3, 2, 1 } };
If it was a jagged array, I would simply call d[0] and that would give me an array of {1, 2, 3, 4, 5}, is there a way I can achieve the same with a 2D array?
No. You could of course write a wrapper class that represents a slice, and has an indexer internally - but nothing inbuilt. The other approach would be to write a method that makes a copy of a slice and hands back a vector - it depends whether you want a copy or not.
using System;
static class ArraySliceExt
{
public static ArraySlice2D<T> Slice<T>(this T[,] arr, int firstDimension)
{
return new ArraySlice2D<T>(arr, firstDimension);
}
}
class ArraySlice2D<T>
{
private readonly T[,] arr;
private readonly int firstDimension;
private readonly int length;
public int Length { get { return length; } }
public ArraySlice2D(T[,] arr, int firstDimension)
{
this.arr = arr;
this.firstDimension = firstDimension;
this.length = arr.GetUpperBound(1) + 1;
}
public T this[int index]
{
get { return arr[firstDimension, index]; }
set { arr[firstDimension, index] = value; }
}
}
public static class Program
{
static void Main()
{
double[,] d = new double[,] { { 1, 2, 3, 4, 5 }, { 5, 4, 3, 2, 1 } };
var slice = d.Slice(0);
for (int i = 0; i < slice.Length; i++)
{
Console.WriteLine(slice[i]);
}
}
}
Improved version of that answer:
public static IEnumerable<T> SliceRow<T>(this T[,] array, int row)
{
for (var i = array.GetLowerBound(1); i <= array.GetUpperBound(1); i++)
{
yield return array[row, i];
}
}
public static IEnumerable<T> SliceColumn<T>(this T[,] array, int column)
{
for (var i = array.GetLowerBound(0); i <= array.GetUpperBound(0); i++)
{
yield return array[i, column];
}
}
Rectangular arrays are not built for this purpose. If you need that type of functionality, you should switch to a jagged array. It is pretty simple to write a function that will convert a rectangular array into a jagged one.
You could also simply rebuild that array by calling GetLength(int dimension) on the appropriate dimension, and then indexing it properly to retrieve each value. It would be cheaper than converting the entire array, but the cheapest option is to change it to use jagged arrays.
This should replicate the a[r] functionality of a jagged array:
T[] Slice<T>(T[,] a, int r) => Enumerable.Range(0, a.GetUpperBound(1) + 1).Select(i => a[r, i]).ToArray();
GetUpperBound(1) + 1 it's clearer to just use GetLength(1).Good answers are already given, but I recently worked on it and created these methods into my libraries:
/// <summary> Iterates the given 2-dimensional array's specified row. A row is all values contained when the left hand index is identical. </summary>
public static IEnumerable<T> IterateRow<T> (T[,] array, int row)
{
int upperBound = array.GetUpperBound (1);
for (int i = array.GetLowerBound (1); i <= upperBound; i++)
{
yield return array[row, i];
}
}
/// <summary> Iterates the given 2-dimensional array's specified column. A column is all values contained when the right hand index is identical. </summary>
public static IEnumerable<T> IterateColumn<T> (T[,] array, int column)
{
int upperBound = array.GetUpperBound (0);
for (int i = array.GetLowerBound (0); i <= upperBound; i++)
{
yield return array[i, column];
}
}
/// <summary> Returns the given 2-dimensional array's specified row. A row is all values contained when the left hand index is identical. </summary>
public static T[] SliceRow<T> (T[,] array, int row)
{
int upperBound = array.GetUpperBound (1);
T[] slice = new T[upperBound + 1];
for (int i = array.GetLowerBound (1); i <= upperBound; i++)
{
slice[i] = array[row, i];
}
return slice;
}
/// <summary> Returns the given 2-dimensional array's specified column. A column is all values contained when the right hand index is identical. </summary>
public static T[] SliceColumn<T> (T[,] array, int column)
{
int upperBound = array.GetUpperBound (0);
T[] slice = new T[upperBound + 1];
for (int i = array.GetLowerBound (0); i <= upperBound; i++)
{
slice[i] = array[i, column];
}
return slice;
}
These are slightly refined. For example "i <= array.GetUpperBound(1)" as written in the other answer would run that method with every iteration. Also there are versions that provide the 1-dimensional arrays directly. I prefer to use the term "Iterate" in method names for iterative methods. I am also no fan of method extensions any more - you may lose overview at some point if they stack up too much. And given that you would (and should) need to add the namespace anyway, it doesn't really speed things up much. In my case I just use "int[] firstRow = UtilityFunctions.SliceRow (myArray, 0);".