Create an array full of -1;

Question

Instead of starting off every value at 0 like c# normally does, I am wondering if there is way to start at a specific number like -1 without having to loop through replacing every 0 with -1 after initialization?

Answer 1

using something like this

 var myArray =  Enumerable.Repeat(-1, 1000000).ToArray();

important note; it is slower than looping manually

Answer 2

Sure, possible.

void Main()
{
    var arr = Enumerable.Repeat(-1, 10).ToArray();  
    Console.WriteLine (arr);
}

Not entirely sure what happens behind the scenes so it will probably still loop over the values in your list. That will be hard to avoid though.

Different solution:

void Main()
{
    var arr = new List<int>(new int[10]).Select(x => x = -1).ToArray();
    Console.WriteLine (arr);
}

Answer 3

You could do this:

public static int[] Initialize( this int[] instance , int value )
{
  if ( instance == null ) throw new ArgumentNullException("instance") ;
  for ( int i = 0 ; i < instance.Length ; ++i )
  {
    instance[i] = value ;
  }
  return instance ;
}

which would let you say something like

int[] foo = new int[2048].Initialize(-1) ;

You might get some performance increase by going unsafe and using pointers, since you won't incur the overhead of array bounds checking, something like this:

public static unsafe int[] Initialize( this int[] instance , int value )
{
  if ( instance == null ) throw new ArgumentNullException("instance") ;
  fixed ( int *addr = instance )
  {
    int *p    = addr ;
    int *pMax = addr+instance.Length ;
    while ( p < pMax )
    {
      *(p++) = value ;
    }
    return instance ;
  }

If you'll only ever want to set the array to -1, you can make it even faster by using memset(), since we know that all the bytes will be 0xFF. So...

    public static unsafe int[] InitializeToMinus1( this int[] instance )
    {
        if ( instance == null ) throw new ArgumentNullException("instance");
        fixed( void *p = instance )
        {
            IntPtr    addr  = new IntPtr(p) ;
            const int hexFF = 0x000000FF ;
            int       bytes = instance.Length * sizeof(int) ;
            memset( addr , hexFF , bytes ) ;
        }
        return instance ;
    }

    [DllImport("msvcrt.dll", EntryPoint="memset", CallingConvention=CallingConvention.Cdecl, SetLastError = false)]
    public static extern IntPtr memset( IntPtr addr , int c , int count ) ;

Answer 4

You can use Repeat:

int[] array = Enumerable.Repeat(-1, 5).ToArray();

As mentioned elsewhere, this is syntactic sugar - a loop will still be run, and you'll incur the overhead of converting the IEnumerable produced back to an array.

Answer 5

Try:

int[] intArray =  Enumerable.Repeat(-1, [Length]).ToArray();

Answer 6

The Enumerable class may help, like below :

IEnumerable<int> array = Enumerable.Repeat(-1, 15);  // or whatever range you'd like

Answer 7

Consider the following Code...

items =  items.Select(s => s = -1).ToArray();

Good Luck!