Example #1
0
    def test_traceback(self):
        score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1],
                   [-9, -5, -1, 6], [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([DNA("ACG-")], [DNA("ACGT")], 1, 0, 0)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': ''})]),
                            TabularMSA([DNA('ACGT', metadata={'id': ''})]), 4,
                            3)
        self.assertEqual(actual, expected)

        # four sequences in two alignments
        score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1],
                   [-9, -5, -1, 6], [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([DNA("ACG-"), DNA("ACG-")], [DNA("ACGT"),
                                                 DNA("ACGT")], 1, 0, 0)
        actual = _traceback(
            tback_m, score_m,
            TabularMSA([
                DNA('ACG', metadata={'id': 's1'}),
                DNA('ACG', metadata={'id': 's2'})
            ]),
            TabularMSA([
                DNA('ACGT', metadata={'id': 's3'}),
                DNA('ACGT', metadata={'id': 's4'})
            ]), 4, 3)
        self.assertEqual(actual, expected)

        # start at highest-score
        expected = ([DNA("ACG")], [DNA("ACG")], 6, 0, 0)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': ''})]),
                            TabularMSA([DNA('ACGT', metadata={'id': ''})]), 3,
                            3)
        self.assertEqual(actual, expected)

        # terminate traceback before top-right
        tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 0, 3], [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        expected = ([DNA("G")], [DNA("G")], 6, 2, 2)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': ''})]),
                            TabularMSA([DNA('ACGT', metadata={'id': ''})]), 3,
                            3)
        self.assertEqual(actual, expected)
Example #2
0
    def test_traceback(self):
        score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1],
                   [-9, -5, -1, 6], [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([BiologicalSequence("ACG-")], [BiologicalSequence("ACGT")],
                    1, 0, 0)
        actual = _traceback(tback_m, score_m, Alignment([DNA('ACG')]),
                            Alignment([DNA('ACGT')]), 4, 3)
        self.assertEqual(actual, expected)

        # four sequences in two alignments
        score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1],
                   [-9, -5, -1, 6], [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([BiologicalSequence("ACG-"),
                     BiologicalSequence("ACG-")],
                    [BiologicalSequence("ACGT"),
                     BiologicalSequence("ACGT")], 1, 0, 0)
        actual = _traceback(tback_m, score_m,
                            Alignment([DNA('ACG', 's1'),
                                       DNA('ACG', 's2')]),
                            Alignment([DNA('ACGT', 's3'),
                                       DNA('ACGT', 's4')]), 4, 3)
        self.assertEqual(actual, expected)

        # start at highest-score
        expected = ([BiologicalSequence("ACG")], [BiologicalSequence("ACG")],
                    6, 0, 0)
        actual = _traceback(tback_m, score_m, Alignment([DNA('ACG')]),
                            Alignment([DNA('ACGT')]), 3, 3)
        self.assertEqual(actual, expected)

        # terminate traceback before top-right
        tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 0, 3], [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        expected = ("G", "G", 6, 2, 2)
        expected = ([BiologicalSequence("G")], [BiologicalSequence("G")], 6, 2,
                    2)
        actual = _traceback(tback_m, score_m, Alignment([DNA('ACG')]),
                            Alignment([DNA('ACGT')]), 3, 3)
        self.assertEqual(actual, expected)
Example #3
0
    def test_traceback(self):
        score_m = [[0, -5, -7, -9],
                   [-5, 2, -3, -5],
                   [-7, -3, 4, -1],
                   [-9, -5, -1, 6],
                   [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3],
                   [2, 1, 3, 3],
                   [2, 2, 1, 3],
                   [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([DNA("ACG-", metadata={'id': 'foo'})],
                    [DNA("ACGT", metadata={'id': 'bar'})], 1, 0, 0)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': 'foo'})]),
                            TabularMSA([DNA('ACGT', metadata={'id': 'bar'})]),
                            4, 3)
        self.assertEqual(actual, expected)

        # four sequences in two alignments
        score_m = [[0, -5, -7, -9],
                   [-5, 2, -3, -5],
                   [-7, -3, 4, -1],
                   [-9, -5, -1, 6],
                   [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3],
                   [2, 1, 3, 3],
                   [2, 2, 1, 3],
                   [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([DNA("ACG-", metadata={'id': 's1'}),
                     DNA("ACG-", metadata={'id': 's2'})],
                    [DNA("ACGT", metadata={'id': 's3'}),
                     DNA("ACGT", metadata={'id': 's4'})],
                    1, 0, 0)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': 's1'}),
                                        DNA('ACG', metadata={'id': 's2'})]),
                            TabularMSA([DNA('ACGT', metadata={'id': 's3'}),
                                        DNA('ACGT', metadata={'id': 's4'})]),
                            4, 3)
        self.assertEqual(actual, expected)

        # start at highest-score
        expected = ([DNA("ACG", metadata={'id': 'foo'})],
                    [DNA("ACG", metadata={'id': 'bar'})], 6, 0, 0)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': 'foo'})]),
                            TabularMSA([DNA('ACGT', metadata={'id': 'bar'})]),
                            3, 3)
        self.assertEqual(actual, expected)

        # terminate traceback before top-right
        tback_m = [[0, 3, 3, 3],
                   [2, 1, 3, 3],
                   [2, 2, 0, 3],
                   [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        expected = ([DNA("G", metadata={'id': 'a'})],
                    [DNA("G", metadata={'id': 'a'})], 6, 2, 2)
        actual = _traceback(tback_m, score_m,
                            TabularMSA([DNA('ACG', metadata={'id': 'a'})]),
                            TabularMSA([DNA('ACGT', metadata={'id': 'a'})]),
                            3, 3)
        self.assertEqual(actual, expected)
Example #4
0
    def test_traceback(self):
        score_m = [[0, -5, -7, -9],
                   [-5, 2, -3, -5],
                   [-7, -3, 4, -1],
                   [-9, -5, -1, 6],
                   [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3],
                   [2, 1, 3, 3],
                   [2, 2, 1, 3],
                   [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([Sequence("ACG-", id='0')],
                    [Sequence("ACGT", id='1')], 1, 0, 0)
        actual = _traceback(tback_m, score_m, Alignment([DNA('ACG')]),
                            Alignment([DNA('ACGT')]), 4, 3)
        self.assertEqual(actual, expected)

        # four sequences in two alignments
        score_m = [[0, -5, -7, -9],
                   [-5, 2, -3, -5],
                   [-7, -3, 4, -1],
                   [-9, -5, -1, 6],
                   [-11, -7, -3, 1]]
        score_m = np.array(score_m)
        tback_m = [[0, 3, 3, 3],
                   [2, 1, 3, 3],
                   [2, 2, 1, 3],
                   [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        # start at bottom-right
        expected = ([Sequence("ACG-", id='s1'), Sequence("ACG-", id='s2')],
                    [Sequence("ACGT", id='s3'), Sequence("ACGT", id='s4')],
                    1, 0, 0)
        actual = _traceback(tback_m, score_m,
                            Alignment([DNA('ACG', 's1'), DNA('ACG', 's2')]),
                            Alignment([DNA('ACGT', 's3'), DNA('ACGT', 's4')]),
                            4, 3)
        self.assertEqual(actual, expected)

        # start at highest-score
        expected = ([Sequence("ACG", id='0')],
                    [Sequence("ACG", id='1')], 6, 0, 0)
        actual = _traceback(tback_m, score_m, Alignment([DNA('ACG')]),
                            Alignment([DNA('ACGT')]), 3, 3)
        self.assertEqual(actual, expected)

        # terminate traceback before top-right
        tback_m = [[0, 3, 3, 3],
                   [2, 1, 3, 3],
                   [2, 2, 0, 3],
                   [2, 2, 2, 1],
                   [2, 2, 2, 2]]
        tback_m = np.array(tback_m)
        expected = ("G", "G", 6, 2, 2)
        expected = ([Sequence("G", id='0')],
                    [Sequence("G", id='1')], 6, 2, 2)
        actual = _traceback(tback_m, score_m, Alignment([DNA('ACG')]),
                            Alignment([DNA('ACGT')]), 3, 3)
        self.assertEqual(actual, expected)