C#/ArrayTools.cs

   1 using System;
   2
   3 namespace IEnumerableExtras
   4 {
   5     /// <summary>
   6     /// Helper class containing tools to deal with arrays
   7     /// </summary>
   8     public static class ArrayTools
   9     {
  10         /// <summary>
  11         /// Convert a x based array to a 0 based array.
  12         /// Only works with one or two dimensional arrays.
  13         /// </summary>
  14         /// <param name="xBased">'x' based array</param>
  15         /// <returns>0 based array</returns>
  16         public static Array ConvertTo0Based( Array xBased )
  17         {
  18             Array zeroBasedArray = null;
  19
  20             // Do nothing if array is null or empty
  21             if ( xBased != null && xBased.Length > 0 )
  22             {
  23                 // Get number of dimensions
  24                 int arrayDimensions = xBased.Rank;
  25
  26                 if ( arrayDimensions == 1 )
  27                 {
  28                     // Code for one dimensional array
  29                     int ubound1 = xBased.GetUpperBound( 0 );
  30                     int lbound1 = xBased.GetLowerBound( 0 );
  31
  32                     zeroBasedArray = Array.CreateInstance( xBased.GetValue( 1 ).GetType(),
  33                                                            new[] {ubound1 - lbound1 + 1}, new[] {0} );
  34
  35                     Array.Copy( xBased, lbound1, zeroBasedArray, 0, xBased.Length );
  36                 }
  37                 else if ( arrayDimensions == 2 )
  38                 {
  39                     // Code for two dimensional arrays
  40                     int ubound1 = xBased.GetUpperBound( 0 );
  41                     int lbound1 = xBased.GetLowerBound( 0 );
  42                     int ubound2 = xBased.GetUpperBound( 1 );
  43                     int lbound2 = xBased.GetLowerBound( 1 );
  44
  45                     zeroBasedArray = Array.CreateInstance( xBased.GetValue( 1, 1 ).GetType(),
  46                                                            new[] {ubound1 - lbound1 + 1, ubound2 - lbound2 + 1},
  47                                                            new[] {0, 0} );
  48
  49                     Array.Copy( xBased, lbound1, zeroBasedArray, 0, xBased.Length );
  50                 }
  51                 else
  52                 {
  53                     throw new ApplicationException( "Cannot rebase arrays of more than 2 dimensions" );
  54                 }
  55             }
  56
  57             return zeroBasedArray;
  58         }
  59
  60
  61         /// <summary>
  62         /// Converts a zero based array to a 1 based array
  63         /// Only works with 1 or 2 dimensional arrays.
  64         /// </summary>
  65         /// <param name="zeroBased">Zero based array</param>
  66         /// <returns>1 based array</returns>
  67         public static Array ConvertTo1Based( Array zeroBased )
  68         {
  69             return ConvertTo1Based( zeroBased, 0, 0 );
  70         }
  71
  72         /// <summary>
  73         /// Converts a zero based array to a 1 based array
  74         /// Only works with 1 or 2 dimensional arrays.
  75         /// </summary>
  76         /// <param name="zeroBased">Zero based array</param>
  77         /// <param name="di">How many rows to skip.</param>
  78         /// <returns>1 based array</returns>
  79         public static Array ConvertTo1Based( Array zeroBased, int di )
  80         {
  81             return ConvertTo1Based( zeroBased, di, 0 );
  82         }
  83
  84         /// <summary>
  85         /// Converts a zero based array to a 1 based array
  86         /// Only works with 1 or 2 dimensional arrays.
  87         /// </summary>
  88         /// <param name="zeroBased">Zero based array</param>
  89         /// <param name="di">How many rows to skip.</param>
  90         /// <param name="dj">How many columns to skip.</param>
  91         /// <returns>1 based array</returns>
  92         public static Array ConvertTo1Based( Array zeroBased, int di, int dj )
  93         {
  94             if ( di < 0 )
  95             {
  96                 throw new ArgumentException( "di must be greater or equal to 0.", "di" );
  97             }
  98             if ( dj < 0 )
  99             {
 100                 throw new ArgumentException( "dj must be greater or equal to 0.", "dj" );
 101             }
 102
 103             Array newArray = null;
 104
 105             if ( zeroBased != null && zeroBased.Length > 0 )
 106             {
 107                 // Get number of dimensions
 108                 int arrayDimensions = zeroBased.Rank;
 109
 110                 if ( arrayDimensions == 1 )
 111                 {
 112                     // Code to copy one dimensional arrays
 113                     int ubound1 = zeroBased.GetUpperBound( 0 ) - di;
 114
 115                     newArray = Array.CreateInstance( zeroBased.GetType().GetElementType(), new[] {ubound1 + 1},
 116                                                      new[] {1} );
 117
 118                     for ( int i = 0; i <= ubound1; ++i )
 119                     {
 120                         newArray.SetValue( zeroBased.GetValue( i + di ), i + 1 );
 121                     }
 122
 123                     //Array.Copy( zeroBased, Math.Abs( di ), newArray, 1, zeroBased.Length );
 124                 }
 125                 else if ( arrayDimensions == 2 )
 126                 {
 127                     // Code to copy two dimensional arrays
 128                     int ubound1 = zeroBased.GetUpperBound( 0 ) - di;
 129                     int ubound2 = zeroBased.GetUpperBound( 1 ) - dj;
 130
 131                     Type type = GetArrayType( zeroBased );
 132
 133                     newArray = Array.CreateInstance( type, new[] {ubound1 + 1, ubound2 + 1}, new[] {1, 1} );
 134
 135
 136                     for ( int i = 0; i <= ubound1; ++i )
 137                     {
 138                         for ( int j = 0; j <= ubound2; ++j )
 139                         {
 140                             newArray.SetValue( zeroBased.GetValue( i + di, j + dj ), i + 1, j + 1 );
 141                         }
 142                     }
 143
 144                     //Array.Copy(zeroBased, Math.Abs(di + dj), newArray, 1, zeroBased.Length);
 145                 }
 146                 else
 147                 {
 148                     throw new ApplicationException( "Cannot rebase arrays of more than 2 dimensions" );
 149                 }
 150             }
 151
 152             return newArray;
 153         }
 154
 155         private static Type GetArrayType( Array array )
 156         {
 157             foreach ( object array1 in array )
 158             {
 159                 if ( array1 != null )
 160                 {
 161                     return array1.GetType();
 162                 }
 163             }
 164
 165             return null;
 166         }
 167
 168         /// <summary>
 169         /// Get onde dimensional array froma two dimensional one.
 170         /// </summary>
 171         /// <param name="array2D"></param>
 172         /// <param name="index"></param>
 173         /// <returns></returns>
 174         public static double[] Extract1dFrom2d( double[,] array2D, int index )
 175         {
 176             int secondDimCount = array2D.GetUpperBound( 1 ) + 1;
 177
 178             double[] result = new double[secondDimCount];
 179
 180             for ( int i = 0; i < secondDimCount; i++ )
 181             {
 182                 result[ i ] = array2D[ index, i ];
 183             }
 184             return result;
 185         }
 186
 187         /// <summary>
 188         /// Convert an istance of <see cref="Array"/> to zero based concrete array.
 189         /// </summary>
 190         /// <typeparam name="TValue"></typeparam>
 191         /// <param name="a"></param>
 192         /// <returns></returns>
 193         public static object AsArray< TValue >( Array a )
 194         {
 195             return AsArray<TValue>( a, 0, 0 );
 196         }
 197
 198         /// <summary>
 199         /// Convert an istance of <see cref="Array"/> to zero based concrete array.
 200         /// </summary>
 201         /// <typeparam name="TValue"></typeparam>
 202         /// <param name="a"></param>
 203         /// <param name="i0">Starting index i</param>
 204         /// <returns></returns>
 205         public static object AsArray< TValue >( Array a, int i0 )
 206         {
 207             return AsArray<TValue>( a, i0, 0 );
 208         }
 209
 210         /// <summary>
 211         /// Convert an istance of <see cref="Array"/> to zero based concrete array.
 212         /// </summary>
 213         /// <typeparam name="TValue"></typeparam>
 214         /// <param name="a"></param>
 215         /// <param name="i0">Starting index i</param>
 216         /// <param name="j0">Starting</param>
 217         /// <returns></returns>
 218         public static object AsArray< TValue >( Array a, int i0, int j0 )
 219         {
 220             object res = null;
 221             if ( a != null )
 222             {
 223                 switch ( a.Rank )
 224                 {
 225                     case 2:
 226                         TValue[,] e =
 227                             new TValue[Math.Max( a.GetUpperBound( 0 ), 0 ) + i0,Math.Max( a.GetUpperBound( 1 ), 0 ) + j0
 228                                 ];
 229                         for ( int i = a.GetLowerBound( 0 ); i <= a.GetUpperBound( 0 ); ++i )
 230                         {
 231                             for ( int j = a.GetLowerBound( 1 ); j <= a.GetUpperBound( 1 ); ++j )
 232                             {
 233                                 e[ i - a.GetLowerBound( 0 ) + i0, j - a.GetLowerBound( 1 ) + j0 ] =
 234                                     ( TValue )a.GetValue( i, j );
 235                             }
 236                         }
 237                         res = e;
 238                         break;
 239                     case 1:
 240                         TValue[] x = new TValue[Math.Max( a.GetUpperBound( 0 ), 0 ) + i0];
 241                         for ( int i = a.GetLowerBound( 0 ); i <= a.GetUpperBound( 0 ); ++i )
 242                         {
 243                             x[ i - a.GetLowerBound( 0 ) + i0 ] = ( TValue )a.GetValue( i );
 244                         }
 245                         res = x;
 246                         break;
 247                     default:
 248                         break;
 249                 }
 250             }
 251             else
 252             {
 253                 res = new TValue[0];
 254             }
 255
 256             return res;
 257         }
 258
 259         /// <summary>
 260         /// Initializes array elements with <paramref name="value"/>.
 261         /// </summary>
 262         /// <param name="array"></param>
 263         /// <param name="value"></param>
 264         public static void Initialize( this Array array, object value )
 265         {
 266             for ( int i = 0; i < array.GetLength( 0 ); i++ )
 267             {
 268                 array.SetValue( value, i );
 269             }
 270         }
 271     }
 272 }