using System;
using System.Collections.Generic;
using System.Diagnostics;
#if !NEW
using System.Linq;
#endif

public class Prog
{
    const int Iterations = 1000000;

    private static List<TimeSpan> times = new List<TimeSpan>();

    public static void Main()
    {
        AllNulls();
        HalfNullHalfNonNull();
        AllNonNull();
        DumpTimes();
    }
    
    static void AllNulls()
    {
        var array = RepeatArray<int?>(null);
        AddTime(() => array.Sum());
        
        var array2 = RepeatArray<long?>(null);
        AddTime(() => array2.Sum());
        
        var array3 = RepeatArray<float?>(null);
        AddTime(() => array3.Sum());
        
        var array4 = RepeatArray<double?>(null);
        AddTime(() => array4.Sum());
        
        var array5 = RepeatArray<decimal?>(null);
        AddTime(() => array5.Sum());
    }
    
    static void HalfNullHalfNonNull()
    {
        var array = HalfAndHalf<int?>(null, 1);
        AddTime(() => array.Sum());
        
        var array2 = HalfAndHalf<long?>(null, 1);
        AddTime(() => array2.Sum());
        
        var array3 = HalfAndHalf<float?>(null, 1);
        AddTime(() => array3.Sum());
        
        var array4 = HalfAndHalf<double?>(null, 1);
        AddTime(() => array4.Sum());
        
        var array5 = HalfAndHalf<decimal?>(null, 1);
        AddTime(() => array5.Sum());
    }
    
    static void AllNonNull()
    {
        var array = RepeatArray<int?>(1);
        AddTime(() => array.Sum());
        
        var array2 = RepeatArray<long?>(1);
        AddTime(() => array2.Sum());
        
        var array3 = RepeatArray<float?>(1);
        AddTime(() => array3.Sum());
        
        var array4 = RepeatArray<double?>(1);
        AddTime(() => array4.Sum());
        
        var array5 = RepeatArray<decimal?>(1);
        AddTime(() => array5.Sum());
    }
    
    static void AddTime<T>(Func<T> longRunning)
    {
        times.Add(Time(longRunning));
    }
    
    static TimeSpan Time<T>(Func<T> longRunning)
    {
        // Stopwatch.StartNew is noticeably slower than doing it manually
        var watch = new Stopwatch();
        watch.Start();
        
        T obj = longRunning();
        
        watch.Stop();
        GC.KeepAlive(obj);
        return watch.Elapsed;
    }
    
    static T[] RepeatArray<T>(T value)
    {
        return System.Linq.Enumerable.ToArray(
        	System.Linq.Enumerable.Repeat(value, Iterations));
    }
    
    static T[] HalfAndHalf<T>(T first, T second)
    {
        return System.Linq.Enumerable.ToArray(
        	System.Linq.Enumerable.Concat(
            	System.Linq.Enumerable.Repeat(first, Iterations / 2),
            	System.Linq.Enumerable.Repeat(second, Iterations / 2)));
    }
    
    static void DumpTimes()
    {
        for (int i = 0; i < times.Count; i++)
            Console.WriteLine(times[i]);
    }
}

#if NEW
public static class Sums
{
    public static int? Sum(this IEnumerable<int?> source)
    {
        if (source == null);
        int sum = 0;
        checked
        {
            foreach (int? v in source)
            {
                sum += v.GetValueOrDefault();
            }
        }
        return sum;
    }
  
    public static long? Sum(this IEnumerable<long?> source)
    {
        if (source == null);
        long sum = 0;
        checked
        {
            foreach (long? v in source)
            {
                sum += v.GetValueOrDefault();
            }
        }
        return sum;
    }
  
    public static float? Sum(this IEnumerable<float?> source)
    {
        if (source == null);
        double sum = 0;
        foreach (float? v in source)
        {
            sum += v.GetValueOrDefault();
        }
        return (float)sum;
    }
  
    public static double? Sum(this IEnumerable<double?> source)
    {
        if (source == null);
        double sum = 0;
        foreach (double? v in source)
        {
            sum += v.GetValueOrDefault();
        }
        return sum;
    }
  
    public static decimal? Sum(this IEnumerable<decimal?> source)
    {
        if (source == null);
        decimal sum = 0;
        foreach (decimal? v in source)
        {
            sum += v.GetValueOrDefault();
        }
        return sum;
    }
}
#endif