public readonly long elapsedTime; // in milliseconds
//public readonly double densityDiffAverage, densityDifferenceDeviation;
//public readonly double editDistanceAverage, editDistanceDeviation;
public MeasurementResultSet(PDLPred originalFormula, IEnumerable<PDLPred> generatedFormulas, long time, VariableCache.ConstraintMode constraintmode,
PdlFilter.Filtermode filtermode, HashSet<char> alphabet, IDictionary<PDLPred, SingleMeasurementResult> cache,
IDictionary<Automaton<BDD>, SingleMeasurementResult> automatonCache)
{
this.originalFormula = originalFormula;
this.alphabet = alphabet;
this.originalAutomaton = originalFormula.GetDFA(alphabet, new CharSetSolver());
this.constraintmode = constraintmode;
this.filtermode = filtermode;
this.elapsedTime = time;
this.results = new List<SingleMeasurementResult>();
foreach (PDLPred generatedFormula in generatedFormulas)
{
SingleMeasurementResult result;
if (cache.ContainsKey(generatedFormula))
{
result = cache[generatedFormula];
}
else
{
result = SingleMeasurementResult.Create(this.originalAutomaton, generatedFormula, this.alphabet, automatonCache);
cache[generatedFormula] = result;
}
this.results.Add(result);
}
// Compute statistics
/*
double densityDiffSum = 0;
int editDistanceSum = 0;
foreach (SingleMeasurementResult result in this.results)
{
densityDiffSum += result.densityDiff;
editDistanceSum += result.editDistance;
}
this.densityDiffAverage = ((double)densityDiffSum) / ((double)this.results.Count);
this.editDistanceAverage = ((double)editDistanceSum) / ((double)this.results.Count);
double densityDiffDeviation = 0;
double editDistanceDeviation = 0;
foreach (SingleMeasurementResult result in this.results)
{
densityDiffDeviation += Math.Pow(result.densityDiff - this.densityDiffAverage, 2.0);
editDistanceDeviation += Math.Pow(((double)result.editDistance) - this.editDistanceAverage, 2.0);
}
densityDiffDeviation /= this.results.Count;
densityDiffDeviation = Math.Sqrt(densityDiffDeviation);
editDistanceDeviation /= this.results.Count;
editDistanceDeviation = Math.Sqrt(editDistanceDeviation);
*/
}
private string GetFilenameTest(Testcase testcase, VariableCache.ConstraintMode constraintMode, PdlFilter.Filtermode filtermode)
{
return String.Format("C:/Users/alexander/Desktop/results/{0}.{1}.{2}.csv", testcase.id, constraintMode, filtermode);
}
public override void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator)
{
this.constraintVariable = variableGenerator.GetFreshVariableName();
ArithExpr myVariable = z3Context.MkIntConst(this.constraintVariable);
z3Solver.Assert(z3Context.MkLe(z3Context.MkInt(0), myVariable));
z3Solver.Assert(z3Context.MkLe(myVariable, z3Context.MkInt(1)));
}
public Measurement.MeasurementResultSet RunBenchmark(Testcase testcase, VariableCache.ConstraintMode constraintMode, PdlFilter.Filtermode filtermode, IDictionary<PDLPred, Measurement.SingleMeasurementResult> cache, IDictionary<Automaton<BDD>, Measurement.SingleMeasurementResult> automatonCache)
{
ICollection<PDLPred> bareResults = new LinkedList<PDLPred>();
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
foreach(PDLPred result in ProblemGeneration.GeneratePDLWithEDn(testcase.language, testcase.alphabet, constraintMode, filtermode)) {
bareResults.Add(result);
}
stopwatch.Stop();
return new Measurement.MeasurementResultSet(testcase.language, bareResults, stopwatch.ElapsedMilliseconds, constraintMode, filtermode, new HashSet<char>(testcase.alphabet), cache, automatonCache);
}
public abstract void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator);
public override void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator)
{
// Take a constraint variable just for good measure
this.constraintVariable = variableGenerator.GetFreshVariableName();
ArithExpr myVariable = z3Context.MkIntConst(this.constraintVariable);
z3Solver.Assert(z3Context.MkEq(myVariable, z3Context.MkInt(0)));
}
private static void GenerateConstraints(CPDLPred choicePred, HashSet<char> alphabet, VariableCache.ConstraintMode constraintMode, Context z3Context, Solver z3Solver)
{
VariableCache variableGenerator = VariableCache.Create(constraintMode);
choicePred.ToSMTConstraints(z3Context, z3Solver, alphabet.Count, variableGenerator);
variableGenerator.GenerateAdditionalConstraints(z3Context, z3Solver);
}
public override void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator)
{
this.constraintVariable = variableGenerator.GetFreshVariableName();
ArithExpr myVariable = z3Context.MkIntConst(this.constraintVariable);
z3Solver.Assert(z3Context.MkEq(myVariable, z3Context.MkInt(0)));
this.originalPosition.ToSMTConstraints(z3Context, z3Solver, alphabetSize, variableGenerator);
this.originalSet.ToSMTConstraints(z3Context, z3Solver, alphabetSize, variableGenerator);
}
private static IEnumerable<PDLPred> Concretize(CPDLPred choicePred, HashSet<char> alphabet, VariableCache.ConstraintMode constraintMode) {
Context z3Context = new Context();
Solver z3Solver = z3Context.MkSolver();
GenerateConstraints(choicePred, alphabet, constraintMode, z3Context, z3Solver);
List<char> alphabetList = new List<char>(alphabet);
IEnumerable<string> choiceVariables = choicePred.GetChoiceVariables();
while (z3Solver.Check() == Status.SATISFIABLE)
{
yield return choicePred.InterpretModel(alphabetList, z3Context, z3Solver.Model);
ExcludeLastModel(choiceVariables, z3Context, z3Solver);
}
}
public static IEnumerable<PDLPred> GeneratePDLWithEDn(PDLPred phi, IEnumerable<char> alphabet, VariableCache.ConstraintMode constConst, PdlFilter.Filtermode filtermode)
{
CPDLPred choiceTree = phi.GetCPDL();
HashSet<char> alphabetHashSet = new HashSet<char>(alphabet);
PdlFilter filter = PdlFilter.Create(filtermode, phi, alphabetHashSet);
// Concretize yields all feasible concretizations of the choiceTree
foreach(PDLPred candidate in Concretize(choiceTree, alphabetHashSet, constConst)) {
if (filter.KeepPredicate(candidate) == true)
{
yield return candidate;
}
}
}
public void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator)
{
this.constraintVariable = variableGenerator.GetCharChoiceVariable(this.originalValue);
ArithExpr myVariable = z3Context.MkIntConst(this.constraintVariable);
z3Solver.Assert(z3Context.MkLe(z3Context.MkInt(0), myVariable));
z3Solver.Assert(z3Context.MkLe(myVariable, z3Context.MkInt(alphabetSize - 1)));
}
public void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator)
{
this.constraintVariable = variableGenerator.GetIntegerChoiceVariable(this.originalValue);
ArithExpr myVariable = z3Context.MkIntConst(this.constraintVariable);
// For now, just concretize in the range [floor(origVal / 2), ceil(origVal * 1.5)]
z3Solver.Assert(z3Context.MkLe(z3Context.MkInt((int)(this.originalValue * 0.5)), myVariable));
z3Solver.Assert(z3Context.MkLe(myVariable, z3Context.MkInt((int)(this.originalValue * 1.5))));
if (this.includeZero == false)
{
z3Solver.Assert(z3Context.MkNot(z3Context.MkEq(z3Context.MkInt(0), myVariable)));
}
}
public void ToSMTConstraints(Context z3Context, Solver z3Solver, int alphabetSize, VariableCache variableGenerator)
{
this.constraintVariable = variableGenerator.GetStringChoiceVariable(this.originalValue);
ArithExpr myVariable = z3Context.MkIntConst(this.constraintVariable);
z3Solver.Assert(z3Context.MkLe(z3Context.MkInt(0), myVariable));
/* We have |s| * |\Sigma| options for concretizing this string
* Thus, since we are 0-based: originalValue.Length * alphabet - 1 */
z3Solver.Assert(z3Context.MkLe(myVariable, z3Context.MkInt(this.originalValue.Length * alphabetSize - 1)));
}
