static void Main(string[] args)
        {
#if DEBUG
            const string testingPath = "C:/Users/Nalyd/Desktop/Current Projects/Github/Solving-TSP-using-GA-ACO/TravellingSalesmanProblem/TSP/TSPInstances/berlin52.tsp";
            var          tspInstance = new TspInstance(testingPath);

            var stoppingCriteriaOptions = new StoppingCriteriaOptions
            {
                StoppingCriteriaType = StoppingCriteriaType.SpecifiedIterations,
                MaximumIterations    = 500
            };

            var gaOptions           = new GAOptions(1000, EncodingType.Permutation, SelectionType.Tos, CrossoverType.Cycle, MutationType.SingleSwap, 0.1, 0.3, stoppingCriteriaOptions);
            var tspGeneticAlgorithm = new TspGeneticAlgorithm(gaOptions, tspInstance);
            tspGeneticAlgorithm.Compute(false);

            //var acoOptions = new ACOOptions(4, 3, 2, 0.01, 2.00, stoppingCriteriaOptions);
            //var aco = new TspAntColonyOptimization(acoOptions, tspInstance);
            //aco.Compute();

            Console.ReadLine();
#else
            Parser.Default.ParseArguments <TspOptions>(args).WithParsed(SolveTsp);
#endif
        }
 /// <summary>
 /// Constructor with params.
 /// </summary>
 /// <param name="gaOptions">The <see cref="GAOptions"/> used in the GA.</param>
 public GeneticAlgorithm(GAOptions gaOptions)
 {
     GaOptions = gaOptions;
     Initialize();
 }
 /// <summary>
 /// Default constructor.
 /// </summary>
 public GeneticAlgorithm()
 {
     GaOptions = new GAOptions();
     Initialize();
 }
 /// <summary>
 /// Constructor with params.
 /// </summary>
 /// <param name="gaOptions"></param>
 /// <param name="tspInstance"></param>
 public TspGeneticAlgorithm(GAOptions gaOptions, TspInstance tspInstance) : base(gaOptions)
 {
     _tspInstance = tspInstance;
 }
        /// <summary>
        /// Solves the TSP problem with the arguments passed from the console.
        /// </summary>
        /// <param name="options">The parsed arguments as <see cref="TspOptions"/> .</param>
        private static void SolveTsp(TspOptions options)
        {
            var tspInstancePath = options.TspInstancePath;
            var tspInstance     = new TspInstance(tspInstancePath);

            var algorithmValue = options.Algorithm;
            EvolutionaryComputationType algorithm;

            if (Enum.TryParse(algorithmValue, true, out algorithm))
            {
                var stoppingCriteriaValue = options.StoppingCriteriaType;
                StoppingCriteriaType stoppingCriteriaType;

                if (Enum.TryParse(stoppingCriteriaValue, true, out stoppingCriteriaType))
                {
                    var stoppingCriteriaOptions = new StoppingCriteriaOptions
                    {
                        StoppingCriteriaType = stoppingCriteriaType
                    };

                    switch (stoppingCriteriaType)
                    {
                    case StoppingCriteriaType.TimeBased:
                        stoppingCriteriaOptions.MinutesPassed = options.StoppingCriteriaTimeMinutes;
                        break;

                    case StoppingCriteriaType.SpecifiedIterations:
                        stoppingCriteriaOptions.MaximumIterations = options.StoppingCriteriaIteration;
                        break;
                    }

                    TimeSpan timeSpan;
                    long     memoryConsumed;
                    long     processMemoryConsumed;
                    var      stopWatch = new Stopwatch();

                    var population = options.Population;
                    switch (algorithm)
                    {
                    // using GA to solve TSP
                    case EvolutionaryComputationType.GeneticAlgorithm:

                        var           selectionOperatorValue = options.SelectionOperator;
                        SelectionType selectionType;
                        if (!Enum.TryParse(selectionOperatorValue, true, out selectionType))
                        {
                            selectionType = SelectionType.Rws;
                        }

                        var           crossoverOperatorType = options.CrossoverOperator;
                        CrossoverType crossoverType;
                        if (!Enum.TryParse(crossoverOperatorType, true, out crossoverType))
                        {
                            crossoverType = CrossoverType.Cycle;
                        }

                        var          mutationOperatorType = options.MutationOperator;
                        MutationType mutationType;
                        if (!Enum.TryParse(mutationOperatorType, true, out mutationType))
                        {
                            mutationType = MutationType.SingleSwap;
                        }

                        var mutationRate = options.MutationRate;
                        var elitisimRate = options.ElitismRate;

                        var genticAlgorithmOptions = new GAOptions(population, EncodingType.Permutation, selectionType, crossoverType, mutationType, mutationRate,
                                                                   elitisimRate, stoppingCriteriaOptions);
                        var tspGeneticAlgorithm = new TspGeneticAlgorithm(genticAlgorithmOptions, tspInstance);

                        var showProgression = options.ShowProgressionComments;

                        stopWatch.Start();
                        tspGeneticAlgorithm.Compute(showProgression);

                        memoryConsumed        = GC.GetTotalMemory(false);
                        processMemoryConsumed = Process.GetCurrentProcess().WorkingSet64;
                        stopWatch.Stop();

                        timeSpan = stopWatch.Elapsed;

                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("Time_Elapsed: {0}\nGC_Memory_Consumed: {1}\nProcess_Memory_Consumed: {2}\nTotal_Cities: {3}",
                                          timeSpan.ToString("mm\\:ss\\.ff"), memoryConsumed, processMemoryConsumed, tspInstance.CitiesLength);
                        break;

                    // using ACO to solve TSP
                    case EvolutionaryComputationType.AntColonyOptimization:
                        var alpha = options.Alpha;
                        var beta  = options.Beta;
                        var rho   = options.Rho;
                        var q     = options.Q;

                        var antColonyOptimizationOptions = new ACOOptions(population, alpha, beta, rho, q, stoppingCriteriaOptions);
                        var tspAntColonyOptimization     = new TspAntColonyOptimization(antColonyOptimizationOptions,
                                                                                        tspInstance);

                        stopWatch.Start();
                        tspAntColonyOptimization.Compute();

                        memoryConsumed        = GC.GetTotalMemory(false);
                        processMemoryConsumed = Process.GetCurrentProcess().WorkingSet64;
                        stopWatch.Stop();

                        timeSpan = stopWatch.Elapsed;

                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("Time_Elapsed: {0}\nGC_Memory_Consumed: {1}\nProcess_Memory_Consumed: {2}\nTotal_Cities: {3}",
                                          timeSpan.ToString("mm\\:ss\\.ff"), memoryConsumed, processMemoryConsumed, tspInstance.CitiesLength);
                        break;
                    }
                }
                else
                {
                    throw new Exception("Stopping Criteria specified does not exist. Use --help for more information.");
                }
            }
            else
            {
                throw new Exception("Algorithm specified does not exist. Use --help for more information.");
            }

            Console.ReadLine();
        }