Update function names. (e5377e79) · Commits · github_fork / Chromap

src/chromap.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@
		#include "temp_mapping.h"
		#include "utils.h"

		#define CHROMAP_VERSION "0.2.3-r434"
		#define CHROMAP_VERSION "0.2.3-r435"

		namespace chromap {

src/index.cc

+27 −24

Original line number	Diff line number	Diff line
		@@ -241,32 +241,35 @@ void Index::CheckIndex(uint32_t num_sequences,
		}
		}

		void Index::HeapMergeSeedHitLists(
		const std::vector<std::vector<uint64_t>> sorted_seed_hit_lists,
		std::vector<uint64_t> &seed_hits) const {
		std::priority_queue<SeedHitInList> heap;
		std::vector<uint32_t> seed_hit_list_indices(sorted_seed_hit_lists.size(), 0);

		for (uint32_t li = 0; li < sorted_seed_hit_lists.size(); ++li) {
		if (sorted_seed_hit_lists[li].size() == 0) {
		void Index::HeapMergeCandidatePositionLists(
		const std::vector<std::vector<uint64_t>> sorted_candidate_position_lists,
		std::vector<uint64_t> &candidate_positions) const {
		std::priority_queue<CandidatePositionWithListIndex> heap;
		std::vector<uint32_t> candidate_position_list_indices(
		sorted_candidate_position_lists.size(), 0);

		for (uint32_t li = 0; li < sorted_candidate_position_lists.size(); ++li) {
		if (sorted_candidate_position_lists[li].size() == 0) {
		continue;
		}
		heap.emplace(li, sorted_seed_hit_lists[li][0]);
		heap.emplace(li, sorted_candidate_position_lists[li][0]);
		}

		while (!heap.empty()) {
		const SeedHitInList min_seed_hit = heap.top();
		const CandidatePositionWithListIndex min_candidate_position = heap.top();
		heap.pop();
		seed_hits.push_back(min_seed_hit.position);
		++seed_hit_list_indices[min_seed_hit.list_index];
		candidate_positions.push_back(min_candidate_position.position);
		++candidate_position_list_indices[min_candidate_position.list_index];

		const uint32_t min_seed_hit_list_index =
		seed_hit_list_indices[min_seed_hit.list_index];
		const std::vector<uint64_t> &min_sorted_seed_hit_list =
		sorted_seed_hit_lists[min_seed_hit.list_index];
		if (min_seed_hit_list_index < min_sorted_seed_hit_list.size()) {
		heap.emplace(min_seed_hit.list_index,
		min_sorted_seed_hit_list[min_seed_hit_list_index]);
		const uint32_t min_candidate_position_list_index =
		candidate_position_list_indices[min_candidate_position.list_index];
		const std::vector<uint64_t> &min_sorted_candidate_position_list =
		sorted_candidate_position_lists[min_candidate_position.list_index];
		if (min_candidate_position_list_index <
		min_sorted_candidate_position_list.size()) {
		heap.emplace(min_candidate_position.list_index,
		min_sorted_candidate_position_list
		[min_candidate_position_list_index]);
		}
		}
		}
		@@ -430,9 +433,9 @@ int Index::GenerateCandidatePositions(
		positive_candidate_position_lists[mi].end());
		}
		}
		HeapMergeSeedHitLists(positive_candidate_position_lists,
		HeapMergeCandidatePositionLists(positive_candidate_position_lists,
		positive_candidate_positions);
		HeapMergeSeedHitLists(negative_candidate_position_lists,
		HeapMergeCandidatePositionLists(negative_candidate_position_lists,
		negative_candidate_positions);
		} else {
		std::sort(positive_candidate_positions.begin(),

src/index.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -90,9 +90,9 @@ class Index {
		uint32_t GetLookupTableSize() const { return kh_size(lookup_table_); }

		private:
		void HeapMergeSeedHitLists(
		const std::vector<std::vector<uint64_t>> sorted_seed_hit_lists,
		std::vector<uint64_t> &seed_hits) const;
		void HeapMergeCandidatePositionLists(
		const std::vector<std::vector<uint64_t>> sorted_candidate_position_lists,
		std::vector<uint64_t> &candidate_positions) const;

		uint64_t GenerateCandidatePositionForSingleSeedHit(
		uint64_t reference_seed_hit, uint64_t read_seed_hit) const;

src/utils.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -42,15 +42,15 @@ struct _mm_history {
		uint32_t repetitive_seed_length;
		};

		// Only used in Index to merge sorted seed hit lists using heap.
		struct SeedHitInList {
		// Only used in Index to merge sorted candidate position lists using heap.
		struct CandidatePositionWithListIndex {
		uint32_t list_index;
		uint64_t position;

		SeedHitInList(uint32_t list_index, uint64_t position)
		CandidatePositionWithListIndex(uint32_t list_index, uint64_t position)
		: list_index(list_index), position(position) {}

		bool operator<(const SeedHitInList &h) const {
		bool operator<(const CandidatePositionWithListIndex &h) const {
		// The inversed direction is to make a min-heap.
		return position > h.position;
		}

Admin message