private LabeledTree <ElementInstantiation, ModelEntity.Connector> SelectRootWithAlternatives(LabeledTree <ElementInstantiation, ModelEntity.Connector> root)
{
var markedRoot = LabeledTree.Node(root.Label.Copy(selected: true), root.Edges);
System.Diagnostics.Debug.WriteLine("Select {0}", root.Label.Element.Name);
if (markedRoot.Label.Element is Problem)
{
return(markedRoot.TransformTopDown((from, via, to) =>
{
if (from == markedRoot.Label && via.Is(ConnectorStereotypes.AddressedBy) && !to.Instance.IsDefined)
{
System.Diagnostics.Debug.WriteLine("Select {0}", to.Element.Name);
return to.Copy(selected: true);
}
else
{
return to;
}
}));
}
else
{
return(markedRoot);
}
}
public void SelectTreeNodes()
{
var tree = LabeledTree.Node(1,
LabeledTree.Edge("a", LabeledTree.Node <int, string>(11)),
LabeledTree.Edge("b", LabeledTree.Node <int, string>(12)));
var nodeOrder = new List <int>();
var edgeOrder = new List <string>();
var expectedTree = LabeledTree.Node(1,
LabeledTree.Edge("a", LabeledTree.Node <int, string>(12)),
LabeledTree.Edge("b", LabeledTree.Node <int, string>(13)));
var actualTree = tree.TransformTopDown((source, edge, target) =>
{
nodeOrder.Add(target);
edgeOrder.Add(edge);
return(source + target);
});
AssertEqualTree(expectedTree, actualTree);
Assert.AreEqual(2, nodeOrder.Count);
Assert.AreEqual(2, edgeOrder.Count);
}
private LabeledTree <ElementInstantiation, ModelEntity.Connector> MarkSelectedNodes(LabeledTree <ElementInstantiation, ModelEntity.Connector> problemSpace, TreeNode treeNode)
{
var edges = from pair in problemSpace.Edges.Zip(treeNode.Nodes.Cast <TreeNode>())
select LabeledTree.Edge(pair.Item1.Label, MarkSelectedNodes(pair.Item1.Target, pair.Item2));
return((!problemSpace.Label.Instance.IsDefined && treeNode.Checked)
.Then(() => LabeledTree.Node(new ElementInstantiation(problemSpace.Label.Element, selected: true), edges))
.Else(() => LabeledTree.Node(problemSpace.Label.Copy(selected: false), edges)));
}
private void AssertEqual <N, E>(LabeledTree <N, E> expectedTree, LabeledTree <N, E> actualTree)
{
Assert.AreEqual(expectedTree.Label, actualTree.Label);
Assert.AreEqual(expectedTree.Edges.Count(), actualTree.Edges.Count());
expectedTree.Edges.Zip(actualTree.Edges).ForEach((e, a) =>
{
Assert.AreEqual(e.Label, a.Label);
AssertEqual(e.Target, a.Target);
});
}
private TreeNode ToTreeNode(LabeledTree <ElementInstantiation, ModelEntity.Connector> dependencyNode)
{
var node = new TreeNode(dependencyNode.Label.Element.Name, ToTreeNodes(dependencyNode.Edges));
if (dependencyNode.Label.Instance.IsDefined)
{
node.ForeColor = System.Drawing.SystemColors.GrayText;
}
node.Checked = dependencyNode.Label.Selected;
node.Expand();
return(node);
}
public void CountLevels()
{
var tree = LabeledTree.Node(1,
LabeledTree.Edge("a", LabeledTree.Node <int, string>(11)),
LabeledTree.Edge("b", LabeledTree.Node <int, string>(12,
LabeledTree.Edge("c", LabeledTree.Node <int, string>(121)))));
Assert.AreEqual(0, tree.Level(1));
Assert.AreEqual(1, tree.Level(11));
Assert.AreEqual(1, tree.Level(12));
Assert.AreEqual(2, tree.Level(121));
Assert.AreEqual(int.MaxValue, tree.Level(1211));
}
public void OnceFilter()
{
var graph = DirectedLabeledGraph.Create(
Tuple.Create("1", "a", "2"),
Tuple.Create("2", "a", "1")
);
var expected = LabeledTree.Node("1",
LabeledTree.Edge("a", LabeledTree.Node <string, string>("2")));
var filter = DirectedLabeledGraph.TraverseEdgeOnlyOnce(EqualityComparer <string> .Default);
AssertEqual(expected, graph.ToTree(filter));
}
public Option <LabeledTree <ElementInstantiation, ModelEntity.Connector> > GetSelectedDependencies(
LabeledTree <ElementInstantiation, ModelEntity.Connector> availableDependencies)
{
dependencyTreeView.Nodes.Clear();
dependencyTreeView.Nodes.Add(ToTreeNode(availableDependencies));
var result = ShowDialog();
var markedTree = (result == System.Windows.Forms.DialogResult.OK)
.Then(() => MarkSelectedNodes(availableDependencies, dependencyTreeView.Nodes[0]));
dependencyTreeView.Nodes.Clear();
return(markedTree);
}
public void TransformSimpleGraphToTree()
{
var graph = DirectedLabeledGraph.Create(
Tuple.Create(1, "a", 2),
Tuple.Create(1, "b", 3),
Tuple.Create(2, "c", 3)
);
var expected = LabeledTree.Node(1,
LabeledTree.Edge("a", LabeledTree.Node(2,
LabeledTree.Edge("c", LabeledTree.Node <int, string>(3)))),
LabeledTree.Edge("b", LabeledTree.Node <int, string>(3)));
AssertEqual(expected, graph.ToTree());
}
public void CountLeafs()
{
var tree = LabeledTree.Node(1,
LabeledTree.Edge("a", LabeledTree.Node <int, string>(11,
LabeledTree.Edge("c", LabeledTree.Node <int, string>(111)),
LabeledTree.Edge("c", LabeledTree.Node <int, string>(112)))),
LabeledTree.Edge("b", LabeledTree.Node <int, string>(12,
LabeledTree.Edge("c", LabeledTree.Node <int, string>(121)))));
Assert.AreEqual(3, tree.Leafs());
Assert.AreEqual(3, tree.Leafs(1));
Assert.AreEqual(2, tree.Leafs(11));
Assert.AreEqual(1, tree.Leafs(12));
Assert.AreEqual(1, tree.Leafs(121));
Assert.AreEqual(0, tree.Leafs(999));
}
/*
* [Test, Ignore("Needs to be run on purpose. Can take a lot of time to run.")]
* public void TestThatGivenAndTrueTypeAreEqual()
* {
* var labeledTrees = CreateLabeledTrees(@"C:\Users\nenad\Desktop\Nnd\doktorske\sets\testgibbs2", @"C:\Users\nenad\Desktop\Nnd\doktorske\sets\out1000");
*
* var pCFGComposer = new LabeledTreePCFGComposer(labeledTrees.ToList());
* pCFGComposer.CalculateProbabilities();
*
* ToCSWriter writer = new ToCSWriter(@"C:\Users\nenad\Desktop\Nnd\doktorske\out1000\idioms\idioms2.txt");
* var sampler = new TBSampler(writer);
* sampler.BookKeeper = new ExtendedBookKeeper();
* sampler.Initialize(pCFGComposer, labeledTrees);
*
* try
* {
* sampler.Train(10, 10, 3);
* }
* catch (ArgumentException e)
* {
* Assert.Fail(e.Message);
* }
*
* Assert.Pass();
* }
*/
static LabeledTree[] CreateLabeledTrees(string sourceDirectory, string outputDirectory)
{
var directoryInfo = new DirectoryInfo(sourceDirectory);
var files = directoryInfo.GetFiles();
LabeledTree[] labeledTrees = new LabeledTree[files.Length];
Parallel.For(0, files.Length, (index) =>
{
var labeledTree = CSTreeCreator.CreateTree(files[index], outputDirectory);
LabeledTreeTransformations.Binarize(labeledTree.Root, new CSNodeCreator());
labeledTrees[index] = labeledTree;
});
return(labeledTrees);
}
public void LabeledTree_ToString()
{
var tree = new Tree<int>(42,
new Tree<int>(19),
new Tree<int>(23,
new Tree<int>(7)
)
);
var ltre = new LabeledTree<int>(new Label<int>(tree, new List<Match> { new Match(1) }), new LabeledTree<int>[] {
new LabeledTree<int>(new Label<int>(tree.Children[0], new List<Match> { new Match(2) }), Array.Empty<LabeledTree<int>>()),
new LabeledTree<int>(new Label<int>(tree.Children[1], new List<Match> { new Match(3) }), new LabeledTree<int>[] {
new LabeledTree<int>(new Label<int>(tree.Children[1].Children[0], new List<Match> { new Match(4) }), Array.Empty<LabeledTree<int>>())
}),
});
Assert.AreEqual("[1 (0$)] 42([2 (0$)] 19(), [3 (0$)] 23([4 (0$)] 7()))", ltre.ToString());
Assert.AreEqual(@"[1 (0$)] 42(
[2 (0$)] 19(),
[3 (0$)] 23(
[4 (0$)] 7()
)
)".Replace("\r", string.Empty), ltre.ToString(indent: 0).Replace("\r", string.Empty));
}
