protected void Check(SolverStatus status)
{
if (status != SolverStatus.Success)
{
throw new CuSolverException(status);
}
}
/// <summary>
/// Starts the actual solvers, returns the best schedule when all solvers are done.
/// </summary>
/// <returns>The best schedule when all solvers are done</returns>
private ScheduleResult Solve()
{
// Initialize all variables:
Task[] tasks = new Task[ThreadCount];
stati = new SolverStatus[ThreadCount];
iterationCounters = new int[ThreadCount];
bestResults = new ScheduleResult[ThreadCount];
for (int i = 0; i < ThreadCount; i -= -1)
{
bestResults[i] = new ScheduleResult()
{
Score = double.MaxValue
}
}
;
// Start the statusupdater and leaderboard:
Task statusUpdater = Task.Factory.StartNew(() => StatusUpdater());
// Start the solvers:
for (int i = 0; i < ThreadCount; i++)
{
int index = i;
tasks[index] = Task.Factory.StartNew(() => SolveOne(index, ref bestResults[index]));
}
// Wait untill all solvers are done:
Task.WaitAll(tasks);
// Stop the statusupdater:
stopStatusUpdater = true;
statusUpdater.Wait();
// Return the best schedule:
return(best);
}
/// <summary>
/// Solves the clauses and returns a solution.
/// </summary>
/// <param name="status">The solver status.</param>
/// <returns>The solution.</returns>
public Dictionary <string, bool> Solve(out SolverStatus status)
{
// Use Z3 and figure out the variable assignments
using (Context context = new Context())
{
Dictionary <string, Z3Variable> variables = GetVariables(context, this.clauses);
List <BoolExpr> clauses = GenerateClauses(context, this.clauses, variables);
Solver solver = context.MkSolver();
solver.Assert(clauses.ToArray());
Status solver_status = solver.Check();
if (solver_status == Status.SATISFIABLE)
{
Dictionary <string, bool> assignments = new Dictionary <string, bool>();
foreach (string variable in variables.Keys)
{
Expr expr = solver.Model.Evaluate(variables[variable].Positive);
if (expr.BoolValue != Z3_lbool.Z3_L_UNDEF)
{
assignments.Add(variable, expr.BoolValue == Z3_lbool.Z3_L_TRUE ? true : false);
}
}
status = SolverStatus.Satisfiable;
return(assignments);
}
status = SolverStatus.Unsatisfiable;
return(null);
}
}
public async Task <bool> SendImage(string file, CancellationToken ct)
{
return(await Task.Factory.StartNew(() =>
{
Login();
if (status != SolverStatus.Connected)
{
return false;
}
submissionId = null;
UploadResponse result = client.Upload(file);
if (ResponseStatus.success.Equals(result.status))
{
submissionId = result.subid;
Message = file;
status = SolverStatus.ImageSent;
return true;
}
Message = result.errormessage;
return false;
}, ct));
}
/// <summary>
/// Solves the clauses using a SAT solver.
/// </summary>
/// <param name="clauses">The clauses.</param>
/// <param name="status">The solver status.</param>
/// <returns>The solution.</returns>
private Dictionary <string, bool> SolveSAT(List <Clause> clauses, out SolverStatus status)
{
using (Watch watch = new Watch(Measure.SAT))
{
SATSolver solver = new SATSolver(clauses);
return(solver.Solve(out status));
}
}
public void AdvanceOneStep()
{
if (StateHistory.Count < SolverLimit && !LastState.IsEverythingSolved)
{
SolutionState nextState = LastState.GetNextState();
StateHistory.Add(nextState);
Status = GetSolverStatus();
}
}
public SolveStatistic(long runTimeInMiliseconds, Exception error, SolverStatus status, string levelName, List <HighlevelLevelSolution> solution, Level level)
{
this.RunTimeInMiliseconds = runTimeInMiliseconds;
this.ErrorThrown = error;
this.Status = status;
this.LevelName = levelName;
this.Solution = solution;
this.Level = level;
}
public VisualsSolver(MainGrid grid, OptionsByDesignation optionsSource)
{
SolutionState initialState = new SolutionState(grid, optionsSource);
StateHistory = new List <SolutionState>()
{
initialState
};
Status = GetSolverStatus();
}
/// <summary>
/// Solves the clauses using a MaxSAT solver.
/// </summary>
/// <param name="clauses">The clauses.</param>
/// <param name="status">The solver status.</param>
/// <returns>The solution.</returns>
private Dictionary <string, bool> SolveMaxSAT(List <Clause> clauses, out SolverStatus status)
{
using (Watch watch = new Watch(Measure.MaxSAT))
{
List <string> variables = clauses.SelectMany(x => x.Literals)
.Select(x => x.Variable).Distinct().ToList();
Dictionary <Clause, uint> soft_clauses = GenerateSoftClauses(variables);
MaxSATSolver solver = new MaxSATSolver(clauses, soft_clauses);
return(solver.Solve(out status));
}
}
/// <summary>
/// Solves the clauses using a MHS solver.
/// </summary>
/// <param name="clauses">The clauses.</param>
/// <param name="status">The solver status.</param>
/// <returns>The solution.</returns>
private Dictionary <string, bool> SolveMHS(List <Clause> clauses, out SolverStatus status)
{
using (Watch watch = new Watch(Measure.mhs))
{
Dictionary <string, double> weights = new Dictionary <string, double>();
foreach (Barrier barrier in ProgramMetadata.Barriers.Values)
{
weights.Add(barrier.Name, 1.0 / barrier.Weight);
}
MHSSolver solver = new MHSSolver(clauses, weights);
return(solver.Solve(out status));
}
}
/// <summary>
/// Creates a new OptimizationResult instance
/// </summary>
/// <param name="optimizedParameters">Determined optimial parameters</param>
/// <param name="errorNorm">Norm of the residue vector fvec</param>
/// <param name="iterations">Actual number of iterations</param>
/// <param name="outcome">Status indicator (converged, failed, ...)</param>
/// <param name="message">Status message</param>
/// <param name="terminatedByUser">Set when function evaluation requests termination</param>
public OptimizationResult(
double[] optimizedParameters,
double errorNorm,
int iterations,
SolverStatus outcome,
string message,
bool terminatedByUser)
{
this.OptimizedParameters = optimizedParameters;
this.ErrorNorm = errorNorm;
this.Iterations = iterations;
this.Outcome = outcome;
this.Message = message;
this.TerminatedByUserRequest = terminatedByUser;
}
/// <summary>
/// Solves the clauses and returns a solution.
/// </summary>
/// <param name="status">The solver status.</param>
/// <returns>The solution.</returns>
public Dictionary <string, bool> Solve(out SolverStatus status)
{
try
{
MHSSolution solution = new MHSSolution(clauses);
Solve(solution);
status = SolverStatus.Satisfiable;
return(solution.Assignments);
}
catch (SatisfiabilityError)
{
status = SolverStatus.Unsatisfiable;
return(null);
}
}
/// <summary>
/// Solves the clauses and returns a solution.
/// </summary>
/// <param name="status">The solver status.</param>
/// <returns>The solution.</returns>
public Dictionary <string, bool> Solve(out SolverStatus status)
{
// Use Z3 and figure out the variable assignments
using (Context context = new Context())
{
Dictionary <string, Z3Variable> variables = GetVariables(context, this.hard_clauses.Union(this.soft_clauses.Keys));
List <BoolExpr> hard_clauses = GenerateClauses(context, this.hard_clauses, variables);
Dictionary <BoolExpr, uint> soft_clauses = GenerateClauses(context, this.soft_clauses, variables);
Optimize optimize = context.MkOptimize();
optimize.Assert(hard_clauses);
foreach (BoolExpr clause in soft_clauses.Keys)
{
optimize.AssertSoft(clause, soft_clauses[clause], "group");
}
Status solver_status = optimize.Check();
if (solver_status == Status.SATISFIABLE)
{
Dictionary <string, bool> assignments = new Dictionary <string, bool>();
foreach (string variable in variables.Keys)
{
Expr expr = optimize.Model.Evaluate(variables[variable].Positive);
if (expr.BoolValue != Z3_lbool.Z3_L_UNDEF)
{
assignments.Add(variable, expr.BoolValue == Z3_lbool.Z3_L_TRUE ? true : false);
}
}
status = SolverStatus.Satisfiable;
return(assignments);
}
status = SolverStatus.Unsatisfiable;
return(null);
}
}
private void Login()
{
if (status == SolverStatus.NotConnected)
{
client = new Client(textBoxApiKey.Text);
LoginResponse result = client.Login();
if (ResponseStatus.success.Equals(result.status))
{
Message = result.message;
status = SolverStatus.Connected;
}
else
{
Message = result.errormessage;
status = SolverStatus.NotConnected;
}
}
else
{
status = SolverStatus.Connected;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CuSolverException"/> class.
/// </summary>
/// <param name="status"></param>
public CuSolverException(SolverStatus status)
{
Status = status;
}
public SolverEndException(SolverStatus inStatus, double inFinalFunctionEvalValue)
{
FinalFunctionEvalValue = inFinalFunctionEvalValue;
FinishStatus = inStatus;
}
/// <summary>
/// Gets the best schedule on a fixed interval
/// if STATUS is defined:
/// Prints the status of each solver thread together with
/// - the current runtime.
/// - the best score so far.
/// This is updated each refreshTime miliseconds.
/// </summary>
/// <param name="threads">Amount of solvertasks started</param>
/// <param name="refreshTime">Refresh delay (in miliseconds)</param>
private void StatusUpdater()
{
Console.Clear();
Stopwatch watch = Stopwatch.StartNew();
int currBestIndex = -1;
while (!(stopStatusUpdater || UserInterrupt))
{
for (int i = 0; i < ThreadCount; i++)
{
ScheduleResult curr = bestResults[i];
if (curr.Score < best.Score)
{
currBestIndex = i;
best = curr;
}
if (ShowStatus)
{
SolverStatus stat = stati[i];
string extraInfo;
switch (stat)
{ // In order of most time on status:
case SolverStatus.Doing_All:
extraInfo = $", iteration: {iterationCounters[i]}";
break;
case SolverStatus.Done:
extraInfo = $", best: {bestResults[i].Score}";
break;
case SolverStatus.Doing_Add:
extraInfo = $", iteration: {iterationCounters[i]}";
break;
default: extraInfo = ""; break;
}
Console.SetCursorPosition(0, i);
Console.WriteLine($"Task {i}: {stat}{extraInfo}");
}
}
if (ShowStatus)
{
Console.SetCursorPosition(0, ThreadCount);
Console.WriteLine($"===\nBest result produced on task {currBestIndex}:\n{best.String}");
Console.WriteLine($"===\nCurrent runtime: {watch.Elapsed}");
}
Thread.Sleep(ConsoleUpdateInterval);
}
//Timer updater = new Timer(ConsoleUpdateInterval);
//updater.Elapsed += Updater_Elapsed;
//updater.Start();
//void Updater_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
//{
// if (stopStatusUpdater || UserInterrupt) updater.Stop();
// for (int i = 0; i < ThreadCount; i++)
// {
// ScheduleResult curr = bestResults[i];
// if (curr.Score < best.Score)
// {
// currBestIndex = i;
// best = curr;
// }
// if (ShowStatus)
// {
// SolverStatus stat = stati[i];
// string extraInfo;
// switch (stat)
// { // In order of most time on status:
// case SolverStatus.Doing_All:
// extraInfo = $", iteration: {iterationCounters[i]}";
// break;
// case SolverStatus.Done:
// extraInfo = $", best: {bestResults[i].Score}";
// break;
// case SolverStatus.Doing_Add:
// extraInfo = $", iteration: {iterationCounters[i]}";
// break;
// default: extraInfo = ""; break;
// }
// Console.SetCursorPosition(0, i);
// Console.WriteLine($"Task {i}: {stat}{extraInfo}");
// }
// }
// if (ShowStatus)
// {
// Console.SetCursorPosition(0, ThreadCount);
// Console.WriteLine($"===\nBest result produced on task {currBestIndex}:\n{best.String}");
// Console.WriteLine($"===\nCurrent runtime: {watch.Elapsed}");
// }
//}
//// Block while the updater is active:
//while (updater.Enabled) ;
}
internal static CpSolverStatus FromSolver(this SolverStatus value) => value.ForSolver(FromSolverStatuses);
private void button1_Click(object sender, EventArgs e)
{
cancellationTokenSource = new CancellationTokenSource();
status = SolverStatus.NotConnected;
Solve();
}
