Python Profile.reduce方法代码示例

# 需要导入模块: from cogent.core.profile import Profile [as 别名]
# 或者: from cogent.core.profile.Profile import reduce [as 别名]
    def test_reduce_operators(self):
        """reduce: should work fine with different operators
        """
        # different operators, normalize input, don't normalize output
        p1 = Profile(array([[1, 0, 0], [0, 1, 0]]), Alphabet="ABC")
        p2 = Profile(array([[1, 0, 0], [0, 0, 1]]), Alphabet="ABC")

        self.assertEqual(p1.reduce(p2).Data, array([[1, 0, 0], [0, 0.5, 0.5]]))
        self.assertEqual(
            p1.reduce(p2, add, normalize_input=True, normalize_output=False).Data, array([[2, 0, 0], [0, 1, 1]])
        )
        self.assertEqual(
            p1.reduce(p2, subtract, normalize_input=True, normalize_output=False).Data, array([[0, 0, 0], [0, 1, -1]])
        )
        self.assertEqual(
            p1.reduce(p2, multiply, normalize_input=True, normalize_output=False).Data, array([[1, 0, 0], [0, 0, 0]])
        )

        self.assertRaises(ProfileError, p1.reduce, p2, divide, normalize_input=True, normalize_output=False)

        # don't normalize and normalize only input
        p3 = Profile(array([[1, 2], [3, 4]]), Alphabet="AB")
        p4 = Profile(array([[4, 3], [2, 1]]), Alphabet="AB")

        self.assertEqual(
            p3.reduce(p4, add, normalize_input=False, normalize_output=False).Data, array([[5, 5], [5, 5]])
        )
        self.assertFloatEqual(
            p3.reduce(p4, add, normalize_input=True, normalize_output=False).Data,
            array([[19 / 21, 23 / 21], [23 / 21, 19 / 21]]),
        )

        # normalize input and output
        p5 = Profile(array([[1, 1, 0, 0], [1, 1, 1, 1]]), Alphabet="ABCD")
        p6 = Profile(array([[1, 0, 0, 0], [1, 0, 0, 1]]), Alphabet="ABCD")

        self.assertEqual(
            p5.reduce(p6, add, normalize_input=True, normalize_output=True).Data,
            array([[0.75, 0.25, 0, 0], [0.375, 0.125, 0.125, 0.375]]),
        )

        # it can collapse empty profiles when normalizing is turned off
        self.assertEqual(
            self.empty.reduce(self.empty, normalize_input=False, normalize_output=False).Data.tolist(), [[]]
        )

# 需要导入模块: from cogent.core.profile import Profile [as 别名]
# 或者: from cogent.core.profile.Profile import reduce [as 别名]

#.........这里部分代码省略.........

        # it will still print with invalid data (e.g if len(CharOrder)
        # doesn't match the data
        p = self.full.copy()
        p.CharOrder = "ABC"

        self.assertEqual(p.prettyPrint(include_header=True), "A\tB\tC\n2\t4\t \n3\t5\t \n4\t8\t ")
        # it will truncate the CharOrder if data is transposed
        # and CharOrder is longer then the number of rows in the
        # transposed data
        self.assertEqual(p.prettyPrint(include_header=True, transpose_data=True), "A\t2\t3\t4\nB\t4\t5\t8")

    def test_prettyPrint_four_cases(self):
        """prettyPrint: with/without header/transpose/limit"""
        p = self.full
        p = self.pp
        self.assertEqual(p.prettyPrint(), "1\t 2\t 3\t 4\n5\t 6\t 7\t 8\n9\t10\t11\t12")
        self.assertEqual(p.prettyPrint(column_limit=3), "1\t 2\t 3\n5\t 6\t 7\n9\t10\t11")
        self.assertEqual(
            p.prettyPrint(column_limit=3, include_header=True), "A\t B\t C\n1\t 2\t 3\n5\t 6\t 7\n9\t10\t11"
        )
        self.assertEqual(
            p.prettyPrint(column_limit=3, include_header=False, transpose_data=True),
            "1\t5\t 9\n2\t6\t10\n3\t7\t11\n4\t8\t12",
        )
        self.assertEqual(
            p.prettyPrint(column_limit=2, include_header=False, transpose_data=True), "1\t5\n2\t6\n3\t7\n4\t8"
        )
        self.assertEqual(
            p.prettyPrint(column_limit=3, include_header=True, transpose_data=True),
            "A\t1\t5\nB\t2\t6\nC\t3\t7\nD\t4\t8",
        )

    def test_reduce_wrong_size(self):
        """reduce: should fail when profiles have different sizes"""
        p1 = Profile(array([[1, 0], [0, 1]]), Alphabet="AB")
        p2 = Profile(array([[1, 0, 0], [1, 0, 0]]), Alphabet="ABC")
        self.assertRaises(ProfileError, p1.reduce, p2)

    def test_reduce_normalization_error(self):
        """reduce: fails when input or output can't be normalized"""
        # Will raise errors when input data can't be normalized
        self.assertRaises(ProfileError, self.empty.reduce, self.empty, add)
        self.assertRaises(ProfileError, self.full.reduce, self.empty_row, add)

        # don't normalize input, but do normalize output
        # fails when one row adds up to zero
        p1 = Profile(array([[3, 3], [4, 4]]), "AB")
        p2 = Profile(array([[3, 3], [-4, -4]]), "AB")
        self.assertRaises(ProfileError, p1.reduce, p2, add, False, True)

    def test_reduce_operators(self):
        """reduce: should work fine with different operators
        """
        # different operators, normalize input, don't normalize output
        p1 = Profile(array([[1, 0, 0], [0, 1, 0]]), Alphabet="ABC")
        p2 = Profile(array([[1, 0, 0], [0, 0, 1]]), Alphabet="ABC")

        self.assertEqual(p1.reduce(p2).Data, array([[1, 0, 0], [0, 0.5, 0.5]]))
        self.assertEqual(
            p1.reduce(p2, add, normalize_input=True, normalize_output=False).Data, array([[2, 0, 0], [0, 1, 1]])
        )
        self.assertEqual(
            p1.reduce(p2, subtract, normalize_input=True, normalize_output=False).Data, array([[0, 0, 0], [0, 1, -1]])
        )
        self.assertEqual(