コード例 #1
0
    def testCanonicalizeByNumberOfTipsAheadOfName(self):
        """
        In forming a canonical tree, child nodes must be sorted by number of
        tips in preference to name.
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(name='a',
                     children=[
                         TreeNode(),
                         TreeNode(),
                         TreeNode(),
                     ]),
            TreeNode(name='b',
                     children=[
                         TreeNode(),
                     ]),
            TreeNode(name='c',
                     children=[
                         TreeNode(),
                         TreeNode(),
                     ]),
        ])

        self.assertEqual(
            ['a', 'b', 'c'],
            [child.name for child in njtree.tree.children])
        self.assertEqual(
            ['b', 'c', 'a'],
            [child.name for child in njtree.canonicalize().tree.children])
コード例 #2
0
    def testCanonicalizeByNameAheadOfNamesOfDescendants(self):
        """
        In forming a canonical tree, child nodes must be sorted by name in
        preference to the sorted names of all their descendants.
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(name='b',
                     children=[
                         TreeNode(name='e'),
                         TreeNode(name='f'),
                         TreeNode(name='g'),
                     ]),
            TreeNode(name='c',
                     children=[
                         TreeNode(name='h'),
                         TreeNode(name='i'),
                         TreeNode(name='j'),
                     ]),
            TreeNode(name='a',
                     children=[
                         TreeNode(name='k'),
                         TreeNode(name='l'),
                         TreeNode(name='m'),
                     ]),
        ])

        self.assertEqual(
            ['b', 'c', 'a'],
            [child.name for child in njtree.tree.children])
        self.assertEqual(
            ['a', 'b', 'c'],
            [child.name for child in njtree.canonicalize().tree.children])
コード例 #3
0
    def testCanonicalizeByTipSubset(self):
        """
        In forming a canonical tree, child nodes must be sorted by the names of
        the set of tips they lead to, if all else is equal.
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(children=[
                TreeNode(name='d'),
                TreeNode(name='e'),
                TreeNode(name='f'),
            ]),
            TreeNode(children=[
                TreeNode(name='g'),
                TreeNode(name='h'),
                TreeNode(name='i'),
            ]),
            TreeNode(children=[
                TreeNode(name='a'),
                TreeNode(name='b'),
                TreeNode(name='c'),
            ]),
        ])

        self.assertEqual(
            ['d', 'e', 'f', 'g', 'h', 'i', 'a', 'b', 'c'],
            [grandchild.name for child in njtree.tree.children
             for grandchild in child.children])
        self.assertEqual(
            ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'],
            [grandchild.name for child in njtree.canonicalize().tree.children
             for grandchild in child.children])
コード例 #4
0
    def testCanonicalizeByNumberOfTips(self):
        """
        In forming a canonical tree, child nodes must be sorted by number
        of tips (assuming child lengths are all equal).
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(children=[
                TreeNode(),
                TreeNode(),
                TreeNode(),
            ]),
            TreeNode(children=[
                TreeNode(),
                TreeNode(),
                TreeNode(),
                TreeNode(),
                TreeNode(),
            ]),
            TreeNode(children=[
                TreeNode(),
                TreeNode(),
            ]),
        ])

        self.assertEqual(
            [3, 5, 2],
            [len(child.children) for child in njtree.tree.children])
        self.assertEqual(
            [2, 3, 5],
            [len(child.children)
             for child in njtree.canonicalize().tree.children])
コード例 #5
0
    def testCanonicalizeByNodeLength(self):
        """
        In forming a canonical tree, child nodes must be sorted by length.
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(length=13),
            TreeNode(length=11),
            TreeNode(length=18),
            TreeNode(length=14)])

        self.assertEqual(
            [13, 11, 18, 14],
            [child.length for child in njtree.tree.children])
        self.assertEqual(
            [11, 13, 14, 18],
            [child.length for child in njtree.canonicalize().tree.children])
コード例 #6
0
    def testCanonicalizeByNodeName(self):
        """
        In forming a canonical tree, child nodes must be sorted by name if node
        lengths and number of tips are equal.
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(name='c'),
            TreeNode(name='d'),
            TreeNode(name='b'),
            TreeNode(name='a')])

        self.assertEqual(
            ['c', 'd', 'b', 'a'],
            [child.name for child in njtree.tree.children])
        self.assertEqual(
            ['a', 'b', 'c', 'd'],
            [child.name for child in njtree.canonicalize().tree.children])
コード例 #7
0
    def testCanonicalizeByLengthAheadOfNumberOfTips(self):
        """
        In forming a canonical tree, child nodes must be sorted by length
        in preference to number of tips.
        """
        njtree = NJTree()
        njtree.tree = TreeNode(children=[
            TreeNode(
                length=13,
                children=[
                    TreeNode(),
                    TreeNode(),
                    TreeNode(),
                ],
            ),
            TreeNode(
                length=11,
                children=[
                    TreeNode(),
                    TreeNode(),
                    TreeNode(),
                    TreeNode(),
                ],
            ),
            TreeNode(
                length=12,
                children=[
                    TreeNode(),
                    TreeNode(),
                ],
            ),
        ])

        self.assertEqual(
            [13, 11, 12],
            [child.length for child in njtree.tree.children])
        self.assertEqual(
            [11, 12, 13],
            [child.length for child in njtree.canonicalize().tree.children])