Exemple #1
0
        private async Task <IList <SatResult> > SolveInstances(IList <SatInstance> instances, bool savePlotInfo)
        {
            var options = GetOptions(savePlotInfo);

            numberOfInstancesTotal    = instances.Count;
            numberOfFinishedInstances = 0;

            var results = await Task.Factory.StartNew(() =>
            {
                var performanceTester = new PerformanceTester();
                performanceTester.RaiseInstanceCalculationFinished += OnInstanceCalculationFinished;
                var res = performanceTester.SolveWithPerformanceTest(instances, options);
                return(res);
            }
                                                      );

            foreach (var result in results)
            {
                result.ResultLabel = CustomRowLabel.Text;
            }

            AddEpsilonValues(results);

            ProgressLabel.Content = "Calculations done!";
            return(results);
        }
        public override void HandleData(CommandLineOptions options)
        {
            //Process and load input instances
            if (!ProcessInputInstances(out var instances, options.InputFile, InputFieldParser.ParseConstructiveKnapsackInstance))
            {
                return;
            }

            var strategy = GetConstructiveStrategy(options.Strategy);

            if (typeof(ConstructiveFPTAS).IsInstanceOfType(strategy))
            {
                AddAproxToInstances(instances, options);
            }

            //var results = strategy.SolveAll(instances, options.Strategy, options.DataSetName);
            var results = PerformanceTester.SolveWithPerformanceTest(instances, strategy, options);

            //Compare with the reference solution if specified
            if (options.ReferenceFile != null)
            {
                if (!ValidateResults <ConstructiveResult, KnapsackInstance>(results, options.ReferenceFile, SolutionValidator.ConstructiveComparator))
                {
                    return;
                }
            }



            //Output the solution
            try
            {
                OutputWriter.WriteConstructiveResults(results, options.OutputFile);
            }
            catch (IOException e)
            {
                Console.WriteLine($"Error while writing into the output file: {e.Message}");
            }
        }
        private async Task <IList <KnapsackResult> > SolveInstances(IList <KnapsackInstance> instances, bool savePlotInfo)
        {
            var options = GetOptions();

            options.SavePlotInfo = savePlotInfo;

            numberOfInstancesTotal = int.Parse(NumberOfInstances.Text);
            var instanceOffset = int.Parse(InstanceOffset.Text);

            numberOfFinishedInstances = 0;

            var results = await Task.Factory.StartNew(() =>
            {
                var performanceTester = new PerformanceTester();
                performanceTester.RaiseInstanceCalculationFinished += OnInstanceCalculationFinished;
                return(performanceTester.SolveWithPerformanceTest(instances.Skip(instanceOffset).Take(numberOfInstancesTotal).ToList(), options));
            }
                                                      );

            ProgressLabel.Content = "Calculations done!";

            return(results);
        }