using System;

using System.Diagnostics;

using System.Threading;

using System.Threading.Tasks;

​

namespace ParallelProgramming.ConsoleApp

{

    class Program

    {

        public static string IntegrationMethod { get; set; }

        public static double IntervalBegin { get; set; }

        public static double IntervalEnd { get; set; }

        public static int NPrecisionValue { get; set; }

        public static bool IsParallel { get; set; }

        public static int ThreadValue { get; set; }

        public static Stopwatch Stopwatch { get; set; }

        public static double Result { get; set; }

​

        static void Main(string[] args)

        {

            Console.WriteLine("Function                                  | Elapsed Time     | Estimated Integral");

            Console.WriteLine("-----------------------------------------------------------------");

​

            IntervalBegin = 5;

            IntervalEnd = -2;

            NPrecisionValue = 100000000;

​

            //RectangularIntegration – Sequential

            NumericalIntegrationMethods integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.RectangularIntegration(IntervalBegin, IntervalEnd, NPrecisionValue);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.RectangularIntegration)} – Sequential | {Stopwatch.Elapsed} | {Result}");

​

            //RectangularIntegrationParallel - 1 thread

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.RectangularIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 1);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.RectangularIntegrationParallel)} – 1 Thread | {Stopwatch.Elapsed} | {Result}");

​

            //RectangularIntegrationParallel - 2 threads

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.RectangularIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 2);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.RectangularIntegrationParallel)} – 2 Threads | {Stopwatch.Elapsed} | {Result}");

​

            //RectangularIntegrationParallel - 3 threads

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.RectangularIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 3);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.RectangularIntegrationParallel)} – 3 Threads | {Stopwatch.Elapsed} | {Result}");

​

            //RectangularIntegrationParallel - 4 threads

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.RectangularIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 4);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.RectangularIntegrationParallel)} – 4 Threads | {Stopwatch.Elapsed} | {Result}");

​

            //TrapezoidalIntegration - Sequential 

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.TrapezoidalIntegration(IntervalBegin, IntervalEnd, NPrecisionValue);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.TrapezoidalIntegration)} – Sequential | {Stopwatch.Elapsed} | {Result}");

​

            //TrapezoidalIntegrationParallel – 1 Thread

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.TrapezoidalIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 1);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.TrapezoidalIntegrationParallel)} – 1 Thread | {Stopwatch.Elapsed} | {Result}");

​

            //TrapezoidalIntegrationParallel – 2 Threads

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.TrapezoidalIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 2);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.TrapezoidalIntegrationParallel)} – 2 Threads | {Stopwatch.Elapsed} | {Result}");

            //TrapezoidalIntegrationParallel – 3 Threads

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.TrapezoidalIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 3);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.TrapezoidalIntegrationParallel)} – 3 Threads | {Stopwatch.Elapsed} | {Result}");

​

            //TrapezoidalIntegrationParallel – 4 Threads

            integral = new();

            Stopwatch = Stopwatch.StartNew();

            Result = integral.TrapezoidalIntegrationParallel(IntervalBegin, IntervalEnd, NPrecisionValue, 4);

            Stopwatch.Stop();

​

            Console.WriteLine($"{nameof(integral.TrapezoidalIntegrationParallel)} – 4 Threads | {Stopwatch.Elapsed} | {Result}");

​

            Console.WriteLine("Press any key to continue...");

            Console.ReadLine();

        }

    }

    public class NumericalIntegrationMethods

    {

        double Function(double x)

        {

            return x * x + 2 * x;

        }

​

        public double RectangularIntegration(double xp, double xk, int n)

        {

            double dx, integral = 0;

            dx = (xk - xp) / n;

​

            for (int i = 1; i <= n; i++)

            {

                integral += dx * Function(xp + i * dx);

                //Console.WriteLine("Sekwencyjnie - iteracja {0} wątek ID: {1}", i, Thread.CurrentThread.ManagedThreadId);

            }

​

            return integral;

        }

​

        public double TrapezoidalIntegration(double xp, double xk, int n)

        {

            double dx, integral = 0;

            dx = (xk - xp) / n;

​

            for (int i = 1; i <= n; i++)

            {

                integral += Function(xp + i * dx);

                //Console.WriteLine("Sekwencyjnie - iteracja {0} wątek ID: {1}", i, Thread.CurrentThread.ManagedThreadId);

            }

​

            integral += (Function(xp) + Function(xk)) / 2;

            integral *= dx;

​

            return integral;

        }

​

        public double RectangularIntegrationParallel(double xp, double xk, int n, int maxThreads)

        {

            double dx, integral = 0;

            dx = (xk - xp) / n;

​

            Parallel.For(1, n + 1, new ParallelOptions { MaxDegreeOfParallelism = maxThreads }, i =>

            {

                integral += dx * Function(xp + i * dx);

                //Console.WriteLine("Równolegle - iteracja {0} wątek ID: {1}", i, Thread.CurrentThread.ManagedThreadId);

            });

​

            return integral;

        }

​

        public double TrapezoidalIntegrationParallel(double xp, double xk, int n, int maxThreads)

        {

            double dx, integral = 0;

            dx = (xk - xp) / n;

​

            Parallel.For(1, n + 1, new ParallelOptions { MaxDegreeOfParallelism = maxThreads }, i =>

            {

                integral += Function(xp + i * dx);

                //Console.WriteLine("Równolegle - iteracja {0} wątek ID: {1}", i, Thread.CurrentThread.ManagedThreadId);

            });

​

            integral += (Function(xp) + Function(xk)) / 2;

            integral *= dx;

​

            return integral;

        }

    }

}

​