Пример #1
0
    def test_get_ordered_coordinates(self):
        """get_ordered_coordinates functions as expected """
        pc_lines = ["Eigvals\t4",
                    "191.54\t169.99\t30.45\t19.19",
                    "",
                    "Proportion explained\t4",
                    "18.13\t16.09\t2.88\t1.66",
                    "",
                    "Species\t0\t0",
                    "",
                    "Site\t5\t4",
                    "s1\t-0.049\t0.245\t0.146\t-0.036",
                    "s5\t-0.267\t-0.228\t-0.024\t-0.095",
                    "s3\t-0.285\t-0.260\t-0.017\t-0.070",
                    "s2\t-0.002\t0.216\t-0.052\t-0.085",
                    "s4\t-0.328\t-0.299\t-0.025\t0.051",
                    "",
                    "Biplot\t0\t0",
                    "",
                    "Site constraints\t0\t0",
                    ""]

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.002, 0.216, -0.052, -0.085],
                           [-0.285, -0.260, -0.017, -0.070],
                           [-0.328, -0.299, -0.025, 0.051],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's2', 's3', 's4', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's2', 's3', 's4', 's5'])
        assert_almost_equal(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's5'])
        assert_almost_equal(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's6', 's5'])
        assert_almost_equal(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        self.assertRaises(ValueError, get_ordered_coordinates,
                          pc[0], pc[1], ['s1', 's6', 's5'], strict=True)
Пример #2
0
    def test_get_ordered_coordinates(self):
        """get_ordered_coordinates functions as expected """
        pc_lines = [
            "Eigvals\t4", "191.54\t169.99\t30.45\t19.19", "",
            "Proportion explained\t4", "18.13\t16.09\t2.88\t1.66", "",
            "Species\t0\t0", "", "Site\t5\t4",
            "s1\t-0.049\t0.245\t0.146\t-0.036",
            "s5\t-0.267\t-0.228\t-0.024\t-0.095",
            "s3\t-0.285\t-0.260\t-0.017\t-0.070",
            "s2\t-0.002\t0.216\t-0.052\t-0.085",
            "s4\t-0.328\t-0.299\t-0.025\t0.051", "", "Biplot\t0\t0", "",
            "Site constraints\t0\t0", ""
        ]

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.002, 0.216, -0.052, -0.085],
                           [-0.285, -0.260, -0.017, -0.070],
                           [-0.328, -0.299, -0.025, 0.051],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's2', 's3', 's4', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's2', 's3', 's4', 's5'])
        assert_almost_equal(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's5'])
        assert_almost_equal(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's6', 's5'])
        assert_almost_equal(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(StringIO('\n'.join(pc_lines)))
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        self.assertRaises(ValueError,
                          get_ordered_coordinates,
                          pc[0],
                          pc[1], ['s1', 's6', 's5'],
                          strict=True)
Пример #3
0
    def test_get_ordered_coordinates(self):
        """get_ordered_coordinates functions as expected """
        pc_lines = [
            "pc vector number\t1\t2\t3\t4", "s1\t-0.049\t0.245\t0.146\t-0.036",
            "s5\t-0.267\t-0.228\t-0.024\t-0.095",
            "s3\t-0.285\t-0.260\t-0.017\t-0.070",
            "s2\t-0.002\t0.216\t-0.052\t-0.085",
            "s4\t-0.328\t-0.299\t-0.025\t0.051", "", "",
            "eigvals\t191.54\t169.99\t30.45\t19.19",
            "% variation explained\t18.13\t16.09\t2.88\t1.66"
        ]

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.002, 0.216, -0.052, -0.085],
                           [-0.285, -0.260, -0.017, -0.070],
                           [-0.328, -0.299, -0.025, 0.051],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's2', 's3', 's4', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's2', 's3', 's4', 's5'])
        self.assertEqual(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's5'])
        self.assertEqual(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        actual_coords, actual_sids = get_ordered_coordinates(
            pc[0], pc[1], ['s1', 's6', 's5'])
        self.assertEqual(actual_coords, expected_coords)
        self.assertEqual(actual_sids, expected_sids)

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1', 's5']
        self.assertRaises(ValueError,
                          get_ordered_coordinates,
                          pc[0],
                          pc[1], ['s1', 's6', 's5'],
                          strict=True)
Пример #4
0
    def test_get_ordered_coordinates(self):
        """get_ordered_coordinates functions as expected """
        pc_lines = ["pc vector number\t1\t2\t3\t4",
                    "s1\t-0.049\t0.245\t0.146\t-0.036",
                    "s5\t-0.267\t-0.228\t-0.024\t-0.095",
                    "s3\t-0.285\t-0.260\t-0.017\t-0.070",
                    "s2\t-0.002\t0.216\t-0.052\t-0.085",
                    "s4\t-0.328\t-0.299\t-0.025\t0.051",
                    "",
                    "",
                    "eigvals\t191.54\t169.99\t30.45\t19.19",
                    "%% variation explained\t18.13\t16.09\t2.88\t1.66"]

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.002, 0.216, -0.052, -0.085],
                           [-0.285, -0.260, -0.017, -0.070],
                           [-0.328, -0.299, -0.025, 0.051],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1','s2','s3','s4','s5']
        actual_coords, actual_sids = get_ordered_coordinates(
         pc[0],pc[1],['s1','s2','s3','s4','s5'])
        self.assertEqual(actual_coords,expected_coords)
        self.assertEqual(actual_sids,expected_sids)

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1','s5']
        actual_coords, actual_sids = get_ordered_coordinates(
         pc[0],pc[1],['s1','s5'])
        self.assertEqual(actual_coords,expected_coords)
        self.assertEqual(actual_sids,expected_sids)

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1','s5']
        actual_coords, actual_sids = get_ordered_coordinates(
         pc[0],pc[1],['s1','s6','s5'])
        self.assertEqual(actual_coords,expected_coords)
        self.assertEqual(actual_sids,expected_sids)

        pc = parse_coords(pc_lines)
        expected_coords = [[-0.049, 0.245, 0.146, -0.036],
                           [-0.267, -0.228, -0.024, -0.095]]
        expected_sids = ['s1','s5']
        self.assertRaises(ValueError,get_ordered_coordinates,
                          pc[0],pc[1],['s1','s6','s5'],strict=True)
Пример #5
0
def ugly_pc_function(m, pc_h, pc, inclusion_fields, disturbed_fields, personal_id, output_fp):

    self_pc1s = []
    self_pc2s = []
    self_pc3s = []
    other_pc1s = []
    other_pc2s = []
    other_pc3s = []

    for inclusion_field in inclusion_fields:
        timeseries_sample_ids = get_timeseries_sample_ids(
            mapping_d=m,
            inclusion_field=inclusion_field,
            inclusion_value="Yes",
            personal_id_field="PersonalID",
            disturbed_fields=disturbed_fields,
            disturbed_value="Yes",
            time_field="WeeksSinceStart",
        )
        try:
            self_sample_ids = [e[1] for e in timeseries_sample_ids[personal_id]]
        except KeyError:
            self_sample_ids = []
        self_coordinates, order = get_ordered_coordinates(pc_h, pc, self_sample_ids)
        self_pc1 = []
        self_pc2 = []
        self_pc3 = []
        for vector in self_coordinates:
            self_pc1.append(vector[0])
            self_pc2.append(vector[1])
            self_pc3.append(vector[2])
        self_pc1s.append(self_pc1)
        self_pc2s.append(self_pc2)
        self_pc3s.append(self_pc3)

        other_sample_ids = []
        for k, v in timeseries_sample_ids.items():
            if k != personal_id:
                other_sample_ids.extend([e[1] for e in v])
        other_coordinates, order = get_ordered_coordinates(pc_h, pc, other_sample_ids)
        other_pc1 = []
        other_pc2 = []
        other_pc3 = []
        for vector in other_coordinates:
            other_pc1.append(vector[0])
            other_pc2.append(vector[1])
            other_pc3.append(vector[2])
        other_pc1s.append(other_pc1)
        other_pc2s.append(other_pc2)
        other_pc3s.append(other_pc3)

    plot_self_v_other_pcoa(
        self_pc1s,
        self_pc2s,
        self_pc3s,
        other_pc1s,
        other_pc2s,
        other_pc3s,
        ["r", "r", "r", "r"],
        ["b", "g", "r", "k"],
        ["gut", "tongue", "palm", "forehead"],
        output_fp,
        disturbed_markers=None,
    )