public void TestProgressiveAligner() { ISequence templateSequence = new Sequence(Alphabets.DNA, "ATGCSWRYKMBVHDN-"); Dictionary <ISequenceItem, int> itemSet = new Dictionary <ISequenceItem, int>(); for (int i = 0; i < templateSequence.Count; ++i) { itemSet.Add(templateSequence[i], i); } Profiles.ItemSet = itemSet; SimilarityMatrix similarityMatrix = new SimilarityMatrix(SimilarityMatrix.StandardSimilarityMatrices.AmbiguousDna); int gapOpenPenalty = -8; int gapExtendPenalty = -1; int kmerLength = 3; ISequence seqA = new Sequence(Alphabets.DNA, "GGGAAAAATCAGATT"); ISequence seqB = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG"); ISequence seqC = new Sequence(Alphabets.DNA, "GGGACAAAATCAG"); List <ISequence> sequences = new List <ISequence>(); sequences.Add(seqA); sequences.Add(seqB); sequences.Add(seqC); KmerDistanceMatrixGenerator kmerDistanceMatrixGenerator = new KmerDistanceMatrixGenerator(sequences, kmerLength, MoleculeType.DNA); kmerDistanceMatrixGenerator.GenerateDistanceMatrix(sequences); IHierarchicalClustering hierarchicalClustering = new HierarchicalClusteringSerial(kmerDistanceMatrixGenerator.DistanceMatrix); BinaryGuideTree tree = new BinaryGuideTree(hierarchicalClustering); IProgressiveAligner progressiveAligner = new ProgressiveAligner(ProfileAlignerNames.NeedlemanWunschProfileAligner, similarityMatrix, gapOpenPenalty, gapExtendPenalty); progressiveAligner.Align(sequences, tree); ISequence expectedSeqA = new Sequence(Alphabets.DNA, "GGGA---AAAATCAGATT"); ISequence expectedSeqB = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG---"); ISequence expectedSeqC = new Sequence(Alphabets.DNA, "GGGA--CAAAATCAG---"); Assert.AreEqual(expectedSeqA.ToString(), progressiveAligner.AlignedSequences[0].ToString()); Assert.AreEqual(expectedSeqB.ToString(), progressiveAligner.AlignedSequences[1].ToString()); Assert.AreEqual(expectedSeqC.ToString(), progressiveAligner.AlignedSequences[2].ToString()); }
public void TestProgressiveAligner() { MsaUtils.SetProfileItemSets(MoleculeType.DNA); SimilarityMatrix similarityMatrix = new SimilarityMatrix(SimilarityMatrix.StandardSimilarityMatrix.AmbiguousDna); int gapOpenPenalty = -8; int gapExtendPenalty = -1; int kmerLength = 4; PAMSAMMultipleSequenceAligner.parallelOption = new ParallelOptions { MaxDegreeOfParallelism = 2 }; ISequence seqA = new Sequence(Alphabets.DNA, "GGGAAAAATCAGATT"); ISequence seqB = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG"); ISequence seqC = new Sequence(Alphabets.DNA, "GGGACAAAATCAG"); List <ISequence> sequences = new List <ISequence>(); sequences.Add(seqA); sequences.Add(seqB); sequences.Add(seqC); KmerDistanceMatrixGenerator kmerDistanceMatrixGenerator = new KmerDistanceMatrixGenerator(sequences, kmerLength, MoleculeType.DNA); kmerDistanceMatrixGenerator.GenerateDistanceMatrix(sequences); IHierarchicalClustering hierarchicalClustering = new HierarchicalClusteringParallel(kmerDistanceMatrixGenerator.DistanceMatrix); BinaryGuideTree tree = new BinaryGuideTree(hierarchicalClustering); IProgressiveAligner progressiveAligner = new ProgressiveAligner(ProfileAlignerNames.NeedlemanWunschProfileAligner, similarityMatrix, gapOpenPenalty, gapExtendPenalty); progressiveAligner.Align(sequences, tree); ISequence expectedSeqA = new Sequence(Alphabets.DNA, "GGGA---AAAATCAGATT"); ISequence expectedSeqB = new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG---"); ISequence expectedSeqC = new Sequence(Alphabets.DNA, "GGGA--CAAAATCAG---"); Assert.AreEqual(expectedSeqA.ToString(), progressiveAligner.AlignedSequences[0].ToString()); Assert.AreEqual(expectedSeqB.ToString(), progressiveAligner.AlignedSequences[1].ToString()); Assert.AreEqual(expectedSeqC.ToString(), progressiveAligner.AlignedSequences[2].ToString()); sequences = new List <ISequence>(); sequences.Add(new Sequence(Alphabets.DNA, "GGGAAAAATCAGATT")); sequences.Add(new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG")); sequences.Add(new Sequence(Alphabets.DNA, "GGGAATCAAAATCAG")); 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")); kmerDistanceMatrixGenerator.GenerateDistanceMatrix(sequences); hierarchicalClustering = new HierarchicalClusteringParallel(kmerDistanceMatrixGenerator.DistanceMatrix); tree = new BinaryGuideTree(hierarchicalClustering); for (int i = 0; i < tree.NumberOfNodes; ++i) { Console.WriteLine("Node {0} ID: {1}", i, tree.Nodes[i].ID); } for (int i = 0; i < tree.NumberOfEdges; ++i) { Console.WriteLine("Edge {0} ID: {1}, length: {2}", i, tree.Edges[i].ID, tree.Edges[i].Length); } SequenceWeighting sw = new SequenceWeighting(tree); for (int i = 0; i < sw.Weights.Length; ++i) { Console.WriteLine("weights {0} is {1}", i, sw.Weights[i]); } progressiveAligner = new ProgressiveAligner(ProfileAlignerNames.NeedlemanWunschProfileAligner, similarityMatrix, gapOpenPenalty, gapExtendPenalty); progressiveAligner.Align(sequences, tree); for (int i = 0; i < progressiveAligner.AlignedSequences.Count; ++i) { Console.WriteLine(progressiveAligner.AlignedSequences[i].ToString()); } MsaUtils.SetProfileItemSets(MoleculeType.Protein); ISequenceParser parser = new FastaParser(); string filepath = @"testdata\FASTA\Protein\BB11001.tfa"; IList <ISequence> orgSequences = parser.Parse(filepath); sequences = MsaUtils.UnAlign(orgSequences); similarityMatrix = new SimilarityMatrix(SimilarityMatrix.StandardSimilarityMatrix.Blosum62); kmerLength = 4; int numberOfSequences = orgSequences.Count; gapOpenPenalty = -13; gapExtendPenalty = -5; kmerDistanceMatrixGenerator = new KmerDistanceMatrixGenerator(sequences, kmerLength, MoleculeType.DNA); kmerDistanceMatrixGenerator.GenerateDistanceMatrix(sequences); hierarchicalClustering = new HierarchicalClusteringParallel(kmerDistanceMatrixGenerator.DistanceMatrix); tree = new BinaryGuideTree(hierarchicalClustering); for (int i = tree.NumberOfLeaves; i < tree.Nodes.Count; ++i) { Console.WriteLine("Node {0}: leftchildren-{1}, rightChildren-{2}", i, tree.Nodes[i].LeftChildren.ID, tree.Nodes[i].RightChildren.ID); } progressiveAligner = new ProgressiveAligner(ProfileAlignerNames.NeedlemanWunschProfileAligner, similarityMatrix, gapOpenPenalty, gapExtendPenalty); progressiveAligner.Align(sequences, tree); for (int i = 0; i < progressiveAligner.AlignedSequences.Count; ++i) { Console.WriteLine(progressiveAligner.AlignedSequences[i].ToString()); } }
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); }