static void CreateTestFile(string dimacs, SolverResult result)
        {
            if (result.Result)
            {
                string clauses = Regex.Match(dimacs, @"p +cnf +\d+ +(\d+)").Groups[1].Value;
                dimacs  = Regex.Replace(dimacs, @"(?<=p +cnf +\d+ +)\d+", int.Parse(clauses) + result.Variables.Count + "");
                dimacs += string.Join(' ', result.Variables.Select(x => $"\n{x.raw} 0"));
            }

            File.WriteAllText(testfile, dimacs);
        }
Beispiel #2
0
        public override SolverResult Run()
        {
            if (Running)
            {
                throw new InvalidOperationException("Solver is already running");
            }
            Running    = true;
            totalwatch = Stopwatch.StartNew();

            InitialUnitPropagation(out bool conflict);

            if (conflict)
            {
                Running = false;
                return(SolverResult.Fail(iterations));
            }

            if (AllAssigned)
            {
                Running = false;
                return(SolverResult.Success(iterations, literals));
            }

            while (true)
            {
                iterations++;
                Literal variable = Branch();
                UnitPropagation(variable, out conflict);

                if (debug)
                {
                    Console.WriteLine($"branching, level: {level} tree: {string.Join(" ", branch.Select(x => x.ToString()).Reverse())}");
                    Console.WriteLine("propagations: " + string.Join(" ", propagates.SelectMany(x => x)));
                    Console.WriteLine("literals: " + string.Join(" ", literals.Select((x, i) => i + ":" + (x == null ? "__" : x.ToString()))));
                    Console.WriteLine();
                }

                if (!conflict && AllAssigned)
                {
                    Running = false;
                    return(SolverResult.Success(iterations, literals));
                }

                if (conflict && leftBranches == 0)
                {
                    Running = false;
                    return(SolverResult.Fail(iterations));
                }

                if (conflict)
                {
                    backtrack = true;
                }

                if (timeout != 0 && totalwatch.ElapsedMilliseconds > timeout)
                {
                    totalwatch.Stop();
                    return(SolverResult.Timeout(iterations, (int)totalwatch.ElapsedMilliseconds));
                }
            }
        }
        public override SolverResult Run()
        {
            if (Running)
            {
                throw new InvalidOperationException("Solver is already running");
            }
            Running    = true;
            totalwatch = Stopwatch.StartNew();

            InitialUnitPropagation(out Conflict conflict);

            if (conflict != null)
            {
                Running = false;
                return(SolverResult.Fail(0));
            }

            if (AllAssigned)
            {
                Running = false;
                return(SolverResult.Success(0, literals));
            }

            if (debug)
            {
                Console.WriteLine();
            }
            while (true)
            {
                if (debug && latestConflict != null)
                {
                    Console.WriteLine("- Conflict");
                    Console.WriteLine(trail.DebugMessage);
                }

                iterations++;
                TrailNode node = Travel();
                UnitPropagation(node, out conflict);

                if (debug)
                {
                    StateDebug();
                }

                if (conflict == null && AllAssigned)
                {
                    Running = false;
                    return(SolverResult.Success(iterations, literals));
                }

                if (conflict != null && level == 0)
                {
                    Running = false;
                    return(SolverResult.Fail(iterations));
                }

                if (conflict != null)
                {
                    latestConflict = conflict;
                }

                if (timeout != 0 && totalwatch.ElapsedMilliseconds > timeout)
                {
                    Running = false;
                    return(SolverResult.Timeout(iterations, (int)totalwatch.ElapsedMilliseconds));
                }
            }
        }