public void TestDistanceMatrix()
{
int dimension = 4;
IDistanceMatrix distanceMatrix = new SymmetricDistanceMatrix(dimension);
for (int i = 0; i < distanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < distanceMatrix.Dimension; ++j)
{
distanceMatrix[i, j] = i + j;
distanceMatrix[j, i] = i + j;
}
}
IHierarchicalClustering hierarchicalClustering = new HierarchicalClusteringSerial(distanceMatrix);
Assert.AreEqual(7, hierarchicalClustering.Nodes.Count);
for (int i = 0; i < dimension * 2 - 1; ++i)
{
Assert.AreEqual(i, hierarchicalClustering.Nodes[i].ID);
}
for (int i = dimension; i < hierarchicalClustering.Nodes.Count; ++i)
{
Console.WriteLine(hierarchicalClustering.Nodes[i].LeftChildren.ID);
Console.WriteLine(hierarchicalClustering.Nodes[i].RightChildren.ID);
}
//Assert.AreEqual(0, hierarchicalClustering.Nodes[4].LeftChildren.ID);
//Assert.AreEqual(1, hierarchicalClustering.Nodes[4].RightChildren.ID);
//Assert.AreEqual(2, hierarchicalClustering.Nodes[5].LeftChildren.ID);
//Assert.AreEqual(4, hierarchicalClustering.Nodes[5].RightChildren.ID);
//Assert.AreEqual(3, hierarchicalClustering.Nodes[6].LeftChildren.ID);
//Assert.AreEqual(5, hierarchicalClustering.Nodes[6].RightChildren.ID);
}
public void TestDistanceMatrix()
{
int dimension = 4;
IDistanceMatrix distanceMatrix = new SymmetricDistanceMatrix(dimension);
for (int i = 0; i < distanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < distanceMatrix.Dimension; ++j)
{
distanceMatrix[i, j] = i + j;
distanceMatrix[j, i] = i + j;
}
}
Assert.AreEqual(dimension, distanceMatrix.Dimension);
Assert.AreEqual(dimension, distanceMatrix.NearestNeighbors.Length);
Assert.AreEqual(dimension, distanceMatrix.NearestDistances.Length);
// Test elements
for (int i = 0; i < distanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < distanceMatrix.Dimension; ++j)
{
Assert.AreEqual(i + j, distanceMatrix[i, j]);
Assert.AreEqual(i + j, distanceMatrix[j, i]);
}
}
// Test NearestNeighbors
Assert.AreEqual(1, distanceMatrix.NearestNeighbors[0]);
Assert.AreEqual(0, distanceMatrix.NearestNeighbors[1]);
Assert.AreEqual(0, distanceMatrix.NearestNeighbors[2]);
Assert.AreEqual(0, distanceMatrix.NearestNeighbors[3]);
Assert.AreEqual(1, distanceMatrix.NearestDistances[0]);
Assert.AreEqual(1, distanceMatrix.NearestDistances[1]);
Assert.AreEqual(2, distanceMatrix.NearestDistances[2]);
Assert.AreEqual(3, distanceMatrix.NearestDistances[3]);
}
public void TestBinaryGuideTree()
{
int numberOfNodes = 5;
List <BinaryGuideTreeNode> nodes = new List <BinaryGuideTreeNode>(numberOfNodes);
for (int i = 0; i < numberOfNodes; ++i)
{
nodes.Add(new BinaryGuideTreeNode(i));
}
nodes[3].LeftChildren = nodes[0];
nodes[3].RightChildren = nodes[1];
nodes[4].LeftChildren = nodes[3];
nodes[4].RightChildren = nodes[2];
nodes[0].Parent = nodes[3];
nodes[1].Parent = nodes[3];
nodes[2].Parent = nodes[4];
nodes[3].Parent = nodes[4];
Assert.IsFalse(nodes[0].IsRoot);
Assert.IsTrue(nodes[0].IsLeaf);
Assert.IsFalse(nodes[1].IsRoot);
Assert.IsTrue(nodes[1].IsLeaf);
Assert.IsFalse(nodes[2].IsRoot);
Assert.IsTrue(nodes[2].IsLeaf);
Assert.IsFalse(nodes[3].IsRoot);
Assert.IsFalse(nodes[3].IsLeaf);
Assert.IsTrue(nodes[4].IsRoot);
Assert.IsFalse(nodes[4].IsLeaf);
Assert.AreEqual(nodes[3], nodes[0].Parent);
int numberOfEdges = 4;
List <BinaryGuideTreeEdge> edges = new List <BinaryGuideTreeEdge>(numberOfEdges);
for (int i = 0; i < numberOfEdges; ++i)
{
edges.Add(new BinaryGuideTreeEdge(i));
}
edges[0].ParentNode = nodes[3];
edges[0].ChildNode = nodes[0];
edges[1].ParentNode = nodes[3];
edges[1].ChildNode = nodes[1];
edges[2].ParentNode = nodes[4];
edges[2].ChildNode = nodes[2];
edges[3].ParentNode = nodes[4];
edges[3].ChildNode = nodes[3];
int dimension = 4;
IDistanceMatrix distanceMatrix = new SymmetricDistanceMatrix(dimension);
for (int i = 0; i < distanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < distanceMatrix.Dimension; ++j)
{
distanceMatrix[i, j] = i + j;
distanceMatrix[j, i] = i + j;
}
}
IHierarchicalClustering hierarchicalClustering = new HierarchicalClusteringSerial(distanceMatrix);
BinaryGuideTree binaryGuideTree = new BinaryGuideTree(hierarchicalClustering);
Assert.AreEqual(7, binaryGuideTree.NumberOfNodes);
Assert.AreEqual(6, binaryGuideTree.NumberOfEdges);
Assert.AreEqual(4, binaryGuideTree.NumberOfLeaves);
Assert.IsTrue(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1].IsRoot);
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.WriteLine(binaryGuideTree.Nodes[i].ID);
}
// Test ExtractSubTreeNodes
Assert.AreEqual(3, binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[4]).Count);
Assert.AreEqual(7, binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count);
Assert.AreEqual(1, binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[0]).Count);
// Test ExtractSubTreeLeafNodes
Assert.AreEqual(2, binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[4]).Count);
Assert.AreEqual(4, binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count);
Assert.AreEqual(1, binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[0]).Count);
// Test FindSmallestTreeDifference
BinaryGuideTree binaryGuideTreeB = new BinaryGuideTree(hierarchicalClustering);
BinaryGuideTreeNode node = BinaryGuideTree.FindSmallestTreeDifference(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1], binaryGuideTreeB.Nodes[binaryGuideTreeB.Nodes.Count - 1]);
Assert.IsNull(node);
node = BinaryGuideTree.FindSmallestTreeDifference(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1], binaryGuideTreeB.Nodes[0]);
Assert.IsNotNull(node);
// Test CompareTwoTrees
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.Write(binaryGuideTree.Nodes[i].ID);
}
for (int i = 0; i < binaryGuideTreeB.Nodes.Count; ++i)
{
Console.Write(binaryGuideTreeB.Nodes[i].ID);
}
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.Write(binaryGuideTree.Nodes[i].ID);
Console.Write(binaryGuideTree.Nodes[i].NeedReAlignment);
binaryGuideTree.Nodes[i].NeedReAlignment = false;
}
for (int i = 0; i < binaryGuideTreeB.Nodes.Count; ++i)
{
Console.Write(binaryGuideTreeB.Nodes[i].ID);
Console.Write(binaryGuideTreeB.Nodes[i].NeedReAlignment);
binaryGuideTreeB.Nodes[i].NeedReAlignment = false;
}
Assert.IsFalse(binaryGuideTree.Nodes[4].NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Nodes[5].NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Nodes[6].NeedReAlignment);
for (int i = binaryGuideTree.NumberOfLeaves; i < binaryGuideTree.NumberOfNodes; ++i)
{
Assert.IsFalse(binaryGuideTree.Nodes[i].NeedReAlignment);
}
binaryGuideTreeB.Root.ID = 7;
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
Assert.IsFalse(binaryGuideTree.Root.NeedReAlignment);
binaryGuideTreeB.Nodes[5].ID = 8;
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.Write(binaryGuideTree.Nodes[i].ID);
Console.Write(binaryGuideTree.Nodes[i].NeedReAlignment);
}
for (int i = 0; i < binaryGuideTreeB.Nodes.Count; ++i)
{
Console.Write(binaryGuideTreeB.Nodes[i].ID);
Console.Write(binaryGuideTreeB.Nodes[i].NeedReAlignment);
}
Assert.IsFalse(binaryGuideTree.Nodes[5].NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Root.NeedReAlignment);
binaryGuideTreeB.Nodes[5].LeftChildren = binaryGuideTreeB.Nodes[3];
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
Assert.IsTrue(binaryGuideTree.Nodes[5].NeedReAlignment);
Assert.IsTrue(binaryGuideTree.Root.NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Nodes[4].NeedReAlignment);
// Test SeparateSequencesByCuttingTree
List <int>[] newSequences = binaryGuideTree.SeparateSequencesByCuttingTree(3);
Assert.AreEqual(2, newSequences[0].Count);
Assert.AreEqual(2, newSequences[1].Count);
List <int>[] newSequencesB = binaryGuideTree.SeparateSequencesByCuttingTree(2);
Assert.AreEqual(1, newSequencesB[0].Count);
Assert.AreEqual(3, newSequencesB[1].Count);
}
public void TestHierarchicalClusteringSerial()
{
int dimension = 4;
IDistanceMatrix distanceMatrix = new SymmetricDistanceMatrix(dimension);
for (int i = 0; i < distanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < distanceMatrix.Dimension; ++j)
{
distanceMatrix[i, j] = i + j;
distanceMatrix[j, i] = i + j;
}
}
PAMSAMMultipleSequenceAligner.ParallelOption = new ParallelOptions {
MaxDegreeOfParallelism = 2
};
IHierarchicalClustering hierarchicalClustering = new HierarchicalClusteringParallel(distanceMatrix);
Assert.AreEqual(7, hierarchicalClustering.Nodes.Count);
for (int i = 0; i < dimension * 2 - 1; ++i)
{
Assert.AreEqual(i, hierarchicalClustering.Nodes[i].ID);
}
for (int i = dimension; i < hierarchicalClustering.Nodes.Count; ++i)
{
Console.WriteLine(hierarchicalClustering.Nodes[i].LeftChildren.ID);
Console.WriteLine(hierarchicalClustering.Nodes[i].RightChildren.ID);
}
// Test on sequences
ISequence seqA = new Sequence(Alphabets.DNA, "GGGAAAAATCAGATT");
ISequence seqB = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG");
ISequence seqC = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG");
List <ISequence> sequences = new List <ISequence>();
sequences.Add(seqA);
sequences.Add(seqB);
sequences.Add(seqC);
sequences.Add(new Sequence(Alphabets.DNA, "GGGAAATCG"));
sequences.Add(new Sequence(Alphabets.DNA, "GGGAATCAATCAG"));
sequences.Add(new Sequence(Alphabets.DNA, "GGGAATCTTATCAG"));
sequences.Add(new Sequence(Alphabets.DNA, "GGGACAAAATCAG"));
sequences.Add(new Sequence(Alphabets.DNA, "GGGAAAAATCAGATT"));
sequences.Add(new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG"));
sequences.Add(new Sequence(Alphabets.DNA, "GGGACAAAATCAG"));
int kmerLength = 4;
KmerDistanceMatrixGenerator kmerDistanceMatrixGenerator =
new KmerDistanceMatrixGenerator(sequences, kmerLength, Alphabets.AmbiguousDNA);
//Console.WriteLine(kmerDistanceMatrixGenerator.Name);
kmerDistanceMatrixGenerator.GenerateDistanceMatrix(sequences);
//Console.WriteLine(kmerDistanceMatrixGenerator.DistanceMatrix);
for (int i = 0; i < kmerDistanceMatrixGenerator.DistanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < kmerDistanceMatrixGenerator.DistanceMatrix.Dimension; ++j)
{
Console.WriteLine("{0}-{1}: {2}", i, j, kmerDistanceMatrixGenerator.DistanceMatrix[i, j]);
}
}
hierarchicalClustering = new HierarchicalClusteringParallel(kmerDistanceMatrixGenerator.DistanceMatrix);
for (int i = 0; i < hierarchicalClustering.Nodes.Count; ++i)
{
Assert.AreEqual(true, hierarchicalClustering.Nodes[i].NeedReAlignment);
}
BinaryGuideTree tree = new BinaryGuideTree(hierarchicalClustering);
for (int i = 0; i < tree.Nodes.Count; ++i)
{
Assert.AreEqual(true, tree.Nodes[i].NeedReAlignment);
}
// SimilarityMatrix similarityMatrix = new SimilarityMatrix(SimilarityMatrix.StandardSimilarityMatrix.AmbiguousDna);
//Assert.AreEqual(0, hierarchicalClustering.Nodes[4].LeftChildren.ID);
//Assert.AreEqual(1, hierarchicalClustering.Nodes[4].RightChildren.ID);
//Assert.AreEqual(2, hierarchicalClustering.Nodes[5].LeftChildren.ID);
//Assert.AreEqual(4, hierarchicalClustering.Nodes[5].RightChildren.ID);
//Assert.AreEqual(3, hierarchicalClustering.Nodes[6].LeftChildren.ID);
//Assert.AreEqual(5, hierarchicalClustering.Nodes[6].RightChildren.ID);
// Test on larger dataset
string filepath = @"TestUtils\Fasta\RV11_BBS_all.afa".TestDir();
FastAParser parser = new FastAParser();
IList <ISequence> orgSequences = parser.Parse(filepath).ToList();
sequences = MsaUtils.UnAlign(orgSequences);
kmerDistanceMatrixGenerator =
new KmerDistanceMatrixGenerator(sequences, kmerLength, Alphabets.AmbiguousDNA);
kmerDistanceMatrixGenerator.GenerateDistanceMatrix(sequences);
hierarchicalClustering = new HierarchicalClusteringParallel(kmerDistanceMatrixGenerator.DistanceMatrix);
for (int i = sequences.Count; i < hierarchicalClustering.Nodes.Count; ++i)
{
Console.WriteLine("Node {0}: leftchildren-{1}, rightChildren-{2}", i, hierarchicalClustering.Nodes[i].LeftChildren.ID, hierarchicalClustering.Nodes[i].RightChildren.ID);
}
}
public void TestBinaryGuideTree()
{
int numberOfNodes = 5;
List <BinaryGuideTreeNode> nodes = new List <BinaryGuideTreeNode>(numberOfNodes);
for (int i = 0; i < numberOfNodes; ++i)
{
nodes.Add(new BinaryGuideTreeNode(i));
}
nodes[3].LeftChildren = nodes[0];
nodes[3].RightChildren = nodes[1];
nodes[4].LeftChildren = nodes[3];
nodes[4].RightChildren = nodes[2];
nodes[0].Parent = nodes[3];
nodes[1].Parent = nodes[3];
nodes[2].Parent = nodes[4];
nodes[3].Parent = nodes[4];
Assert.IsFalse(nodes[0].IsRoot);
Assert.IsTrue(nodes[0].IsLeaf);
Assert.IsFalse(nodes[1].IsRoot);
Assert.IsTrue(nodes[1].IsLeaf);
Assert.IsFalse(nodes[2].IsRoot);
Assert.IsTrue(nodes[2].IsLeaf);
Assert.IsFalse(nodes[3].IsRoot);
Assert.IsFalse(nodes[3].IsLeaf);
Assert.IsTrue(nodes[4].IsRoot);
Assert.IsFalse(nodes[4].IsLeaf);
Assert.AreEqual(nodes[3], nodes[0].Parent);
int numberOfEdges = 4;
List <BinaryGuideTreeEdge> edges = new List <BinaryGuideTreeEdge>(numberOfEdges);
for (int i = 0; i < numberOfEdges; ++i)
{
edges.Add(new BinaryGuideTreeEdge(i));
}
edges[0].ParentNode = nodes[3];
edges[0].ChildNode = nodes[0];
edges[1].ParentNode = nodes[3];
edges[1].ChildNode = nodes[1];
edges[2].ParentNode = nodes[4];
edges[2].ChildNode = nodes[2];
edges[3].ParentNode = nodes[4];
edges[3].ChildNode = nodes[3];
int dimension = 4;
IDistanceMatrix distanceMatrix = new SymmetricDistanceMatrix(dimension);
for (int i = 0; i < distanceMatrix.Dimension - 1; ++i)
{
for (int j = i + 1; j < distanceMatrix.Dimension; ++j)
{
distanceMatrix[i, j] = i + j;
distanceMatrix[j, i] = i + j;
}
}
PAMSAMMultipleSequenceAligner.parallelOption = new ParallelOptions {
MaxDegreeOfParallelism = 2
};
IHierarchicalClustering hierarchicalClustering = new HierarchicalClusteringParallel(distanceMatrix);
BinaryGuideTree binaryGuideTree = new BinaryGuideTree(hierarchicalClustering);
Assert.AreEqual(7, binaryGuideTree.NumberOfNodes);
Assert.AreEqual(6, binaryGuideTree.NumberOfEdges);
Assert.AreEqual(4, binaryGuideTree.NumberOfLeaves);
Assert.IsTrue(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1].IsRoot);
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.WriteLine(binaryGuideTree.Nodes[i].ID);
}
// Test ExtractSubTreeNodes
Console.WriteLine("binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[4]).Count : {0}", binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[4]).Count);
Console.WriteLine("binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count : {0}", binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count);
Console.WriteLine("binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[0]).Count : {0}", binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[0]).Count);
//Assert.AreEqual(3, binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[4]).Count);
//Assert.AreEqual(7, binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count);
//Assert.AreEqual(1, binaryGuideTree.ExtractSubTreeNodes(binaryGuideTree.Nodes[0]).Count);
// Test ExtractSubTreeLeafNodes
Console.WriteLine("binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[4]).Count : {0}", binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[4]).Count);
Console.WriteLine("binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Coun : {0}", binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count);
Console.WriteLine("binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[0]).Count : {0}", binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[0]).Count);
//Assert.AreEqual(2, binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[4]).Count);
//Assert.AreEqual(4, binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1]).Count);
//Assert.AreEqual(1, binaryGuideTree.ExtractSubTreeLeafNodes(binaryGuideTree.Nodes[0]).Count);
// Test FindSmallestTreeDifference
BinaryGuideTree binaryGuideTreeB = new BinaryGuideTree(hierarchicalClustering);
BinaryGuideTreeNode node = BinaryGuideTree.FindSmallestTreeDifference(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1], binaryGuideTreeB.Nodes[binaryGuideTreeB.Nodes.Count - 1]);
Assert.IsNull(node);
node = BinaryGuideTree.FindSmallestTreeDifference(binaryGuideTree.Nodes[binaryGuideTree.Nodes.Count - 1], binaryGuideTreeB.Nodes[0]);
Assert.IsNotNull(node);
// Test CompareTwoTrees
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.Write(binaryGuideTree.Nodes[i].ID);
}
for (int i = 0; i < binaryGuideTreeB.Nodes.Count; ++i)
{
Console.Write(binaryGuideTreeB.Nodes[i].ID);
}
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.Write(binaryGuideTree.Nodes[i].ID);
Console.Write(binaryGuideTree.Nodes[i].NeedReAlignment);
binaryGuideTree.Nodes[i].NeedReAlignment = false;
}
for (int i = 0; i < binaryGuideTreeB.Nodes.Count; ++i)
{
Console.Write(binaryGuideTreeB.Nodes[i].ID);
Console.Write(binaryGuideTreeB.Nodes[i].NeedReAlignment);
binaryGuideTreeB.Nodes[i].NeedReAlignment = false;
}
Assert.IsFalse(binaryGuideTree.Nodes[4].NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Nodes[5].NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Nodes[6].NeedReAlignment);
for (int i = binaryGuideTree.NumberOfLeaves; i < binaryGuideTree.NumberOfNodes; ++i)
{
Assert.IsFalse(binaryGuideTree.Nodes[i].NeedReAlignment);
}
binaryGuideTreeB.Root.ID = 7;
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
Assert.IsFalse(binaryGuideTree.Root.NeedReAlignment);
binaryGuideTreeB.Nodes[5].ID = 8;
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
for (int i = 0; i < binaryGuideTree.Nodes.Count; ++i)
{
Console.WriteLine(binaryGuideTree.Nodes[i].ID);
Console.WriteLine(binaryGuideTree.Nodes[i].NeedReAlignment);
}
for (int i = 0; i < binaryGuideTreeB.Nodes.Count; ++i)
{
Console.WriteLine(binaryGuideTreeB.Nodes[i].ID);
Console.WriteLine(binaryGuideTreeB.Nodes[i].NeedReAlignment);
}
Assert.IsFalse(binaryGuideTree.Nodes[5].NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Root.NeedReAlignment);
binaryGuideTreeB.Nodes[5].LeftChildren = binaryGuideTreeB.Nodes[3];
BinaryGuideTree.CompareTwoTrees(binaryGuideTree, binaryGuideTreeB);
Assert.IsTrue(binaryGuideTree.Nodes[5].NeedReAlignment);
Assert.IsTrue(binaryGuideTree.Root.NeedReAlignment);
Assert.IsFalse(binaryGuideTree.Nodes[4].NeedReAlignment);
// Test SeparateSequencesByCuttingTree
List <int>[] newSequences = binaryGuideTree.SeparateSequencesByCuttingTree(3);
//Assert.AreEqual(2, newSequences[0].Count);
//Assert.AreEqual(2, newSequences[1].Count);
Console.WriteLine("newSequences[0].Count: {0}", newSequences[0].Count);
Console.WriteLine("newSequences[1].Count: {0}", newSequences[1].Count);
List <int>[] newSequencesB = binaryGuideTree.SeparateSequencesByCuttingTree(2);
//Assert.AreEqual(1, newSequencesB[0].Count);
//Assert.AreEqual(3, newSequencesB[1].Count);
Console.WriteLine("newSequences[0].Count: {0}", newSequencesB[0].Count);
Console.WriteLine("newSequences[1].Count: {0}", newSequencesB[1].Count);
// Cut tree test
ISequence seq1 = new Sequence(Alphabets.DNA, "GGGAAAAATCAGATT");
ISequence seq2 = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG");
ISequence seq3 = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG");
ISequence seq4 = new Sequence(Alphabets.DNA, "GGGAAATCG");
ISequence seq5 = new Sequence(Alphabets.DNA, "GGGAATCAATCAG");
ISequence seq6 = new Sequence(Alphabets.DNA, "GGGACAAAATCAG");
ISequence seq7 = new Sequence(Alphabets.DNA, "GGGAATCTTATCAG");
List <ISequence> sequences = new List <ISequence>();
sequences.Add(seq1);
sequences.Add(seq2);
sequences.Add(seq3);
sequences.Add(seq4);
sequences.Add(seq5);
sequences.Add(seq6);
sequences.Add(seq7);
// Generate DistanceMatrix
KmerDistanceMatrixGenerator kmerDistanceMatrixGenerator =
new KmerDistanceMatrixGenerator(sequences, 2, MoleculeType.DNA, DistanceFunctionTypes.EuclideanDistance);
// Hierarchical clustering
IHierarchicalClustering hierarcicalClustering = new HierarchicalClusteringParallel(kmerDistanceMatrixGenerator.DistanceMatrix, UpdateDistanceMethodsTypes.Average);
//// Generate Guide Tree
binaryGuideTree = new BinaryGuideTree(hierarcicalClustering);
// CUT Tree
BinaryGuideTree[] subtrees = binaryGuideTree.CutTree(3);
Assert.IsNotNull(subtrees);
}
