using System.Collections.Concurrent;

using System.Threading.Tasks;

using System.Linq;

using System.Diagnostics;

using System;

public class Program

{

    public const int length = 1000000, dim = 100;

    private static double[][] map;

    public static void Main()

    {

        int[] source = Enumerable.Range(0, length).ToArray();

        long[] targetSequential = new long[length];

        long[] targetParallel = new long[length];

        var r = new Random();

        map = Enumerable.Range(0, dim).Select(x => 

                   Enumerable.Range(0, dim).Select(y => r.NextDouble()).ToArray())

               .ToArray();

        Stopwatch sw = Stopwatch.StartNew();

        MainGeneration(source, targetSequential, false, true);

        sw.Stop();

        Console.WriteLine("Ellapsed ms (Sequential): {0}", sw.ElapsedMilliseconds);

        sw.Restart();

        MainGeneration(source, targetParallel, true, true);

        sw.Stop();

        Console.WriteLine("Ellapsed ms (Parallel): {0}", sw.ElapsedMilliseconds);

    }

    private static void MainGeneration(int[] source, long[] target, bool asParallel, bool bigCalculations)

    {

        long i = 0;

        if(asParallel)

            Parallel.ForEach(Partitioner.Create(source, true).GetOrderableDynamicPartitions(), intItem =>

            {

                i = intItem.Key;

                target[i] = Map(intItem.Value, i, bigCalculations);

            });

        else

            foreach(int num in source) 

            {

                target[i] = Map(num, i, bigCalculations);

                ++i;

            }

    }

    private static long Map(long num, long i, bool bigCalculations)

    {

        if(!bigCalculations) return num;

        if(i < 10000)

            return num;

        else if(i < 50000)

            return num * num;

        else if(i < 100000) 

        {

            long k = 0;

            for(int j = 0; j < 1000; ++j)

            {

                k += num + j - i;

            }

            return k;

        }

        else if(i < 200000) 

        {

            long n = 0;

            for(int l = 0; l < dim; ++l)

                for(int m = 0; m < dim; ++m) {

                    n += (long)(map[l][m] * 1000);

                }

        }

        return (long)(num * Math.PI);

    }                

}