public IList <IList <double> > DistanceMatrix(IList <Snapshot> snapshots, MarkovModelOptions options,
DirectoryHandler handler, DevAssignment assignment)
{
var distances = CreateSquareMatrix(snapshots.Count);
for (var row = 0; row < snapshots.Count; ++row)
{
var left = snapshots[row];
var leftRoot = CreateOrDefualtAbstractSyntaxTreeNode(left, handler, assignment);
for (var col = row + 1; col < snapshots.Count; ++col)
{
var distance = 0.0;
var right = snapshots[col];
distance += CalculateBuildDistance(left, right, options);
distance += CalculateTestDistance(left, right, options, assignment);
var rightRoot = CreateOrDefualtAbstractSyntaxTreeNode(right, handler, assignment);
distance += CalculateMetricDistance(leftRoot, rightRoot, assignment, options);
distances[row][col] = distance;
distances[col][row] = distance;
}
}
return(distances);
}
public double CalculateBuildDistance(Snapshot left, Snapshot right, MarkovModelOptions options)
{
var leftValue = left.Report.Type == SnapshotReport.SnapshotReportTypes.Success ? options.BuildWeight : 0.0d;
var rightValue = right.Report.Type == SnapshotReport.SnapshotReportTypes.Success ? options.BuildWeight : 0.0d;
return(Math.Pow(leftValue - rightValue, 2.0d));
}
private async Task RunMarkovModelImpl(DevAssignment assignment, MarkovModelOptions options)
{
using (var handler =
new DirectoryHandler(Path.Combine(Options.RootDirectory, GetUniqueFolderName(Options.RootDirectory))))
{
await Runner.RunMarkovModel(assignment, options, handler);
}
}
public async Task RunMarkovModel(DevAssignment assignment, MarkovModelOptions options, DirectoryHandler directory)
{
var snapshots = assignment.Snapshots.ToList();
if (options.BuildOnly)
{
snapshots = snapshots.Where(x => x.Report.Type == SnapshotReport.SnapshotReportTypes.Success).ToList();
}
await MarkovModelGenerator.Generate(snapshots, options, directory, assignment);
}
public async Task RunMarkovModel(DevAssignment assignment, MarkovModelOptions options)
{
try
{
await RunMarkovModelImpl(assignment, options);
}
catch (Exception exception)
{
LogException(exception, assignment);
}
}
public async Task <IActionResult> OnGetAsync()
{
Assignment = await Assignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
Context.Entry(Assignment).Collection(x => x.Snapshots)
.Query().Include(x => x.Report).Load();
Options = new MarkovModelOptions();
return(Page());
}
public async Task Generate(IList <Snapshot> snapshots, MarkovModelOptions options, DirectoryHandler handler, DevAssignment assignment)
{
var markovModel = new MarkovModel()
{
Assignment = assignment,
Finished = false,
};
await MarkovModelRepository.Add(markovModel);
var distanceMatrix = DistanceMatrix(snapshots, options, handler, assignment);
markovModel.States = MarkovModelCreator.Create(snapshots, distanceMatrix, options.NumberOfStates);
markovModel.Finished = true;
await MarkovModelRepository.Update(markovModel);
}
private double CalculateTestDistance(Snapshot left, Snapshot right, MarkovModelOptions options, DevAssignment assignment)
{
if (left.Report.Type == SnapshotReport.SnapshotReportTypes.Failure &&
right.Report.Type == SnapshotReport.SnapshotReportTypes.Failure)
{
return(0.0d);
}
if (left.Report.Type == SnapshotReport.SnapshotReportTypes.Failure)
{
var report = (SnapshotSuccessReport)right.Report;
var sum = report
.UnitTestResults
.Select(x => x.Passed ? Math.Pow(options.TestWeight, 2.0f) : 0.0d)
.Sum();
return(sum);
}
if (right.Report.Type == SnapshotReport.SnapshotReportTypes.Failure)
{
var report = (SnapshotSuccessReport)left.Report;
var sum = report
.UnitTestResults
.Select(x => x.Passed ? Math.Pow(options.TestWeight, 2.0f) : 0.0d)
.Sum();
return(sum);
}
var leftReport = (SnapshotSuccessReport)left.Report;
var rightReport = (SnapshotSuccessReport)right.Report;
var accumulator = 0.0d;
foreach (var unitTest in assignment.TestProject.UnitTests)
{
var leftTest = leftReport.UnitTestResults.Single(x => x.UnitTestId.Equals(unitTest.Id));
var rightTest = rightReport.UnitTestResults.Single(x => x.UnitTestId.Equals(unitTest.Id));
var leftValue = leftTest.Passed ? options.TestWeight : 0.0d;
var rightValue = rightTest.Passed ? options.TestWeight : 0.0d;
accumulator += Math.Pow(leftValue - rightValue, 2);
}
return(accumulator);
}
public void RunMarkovModel(int id, MarkovModelOptions options)
{
BackgroundJob.Enqueue(() => RunMarkovModelImpl(id, options));
}
public async Task RunMarkovModelImpl(int id, MarkovModelOptions options)
{
var assignment = await AssignmentRepository.Get(id);
await Engine.RunMarkovModel(assignment, options);
}
private double CalculateMetricDistance(AbstractSyntaxTreeNode leftRoot, AbstractSyntaxTreeNode rightRoot, DevAssignment assignment, MarkovModelOptions options)
{
if (leftRoot == null && rightRoot == null)
{
return(0.0d);
}
var accumlator = 0.0d;
foreach (var methodDeclarration in assignment.Solution.MethodDeclarations)
{
var leftNode = leftRoot == null ? null : GetMethodOrDefault(leftRoot, methodDeclarration);
var rightNode = rightRoot == null ? null : GetMethodOrDefault(leftRoot, methodDeclarration);
if (leftNode != null && rightNode != null)
{
var abstractSyntaxTreeMetric = AbstractSyntaxTreeMetricCreator.Create(leftNode, rightNode);
var bagOfWordsMetric = BagOfWordsMetricCreator.Create(leftNode, rightNode);
accumlator += Math.Pow(abstractSyntaxTreeMetric.Rotations * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(abstractSyntaxTreeMetric.Insertations * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(abstractSyntaxTreeMetric.Deletions * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(bagOfWordsMetric.Difference * options.BagOfWordsWeight, 2);
}
else if (leftNode != null)
{
var amount = leftNode.NumberOfNodes();
accumlator += Math.Pow(amount * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(amount * options.BagOfWordsWeight, 2);
}
else if (rightNode != null)
{
var amount = rightNode.NumberOfNodes();
accumlator += Math.Pow(amount * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(amount * options.BagOfWordsWeight, 2);
}
}
return(accumlator);
}
public Task Generate(IList <Snapshot> snapshots, MarkovModelOptions options, DirectoryHandler handler, Assignment assignment)
{
throw new System.NotImplementedException();
}
