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

src/chromap.h

+1 −1

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

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

	namespace chromap {		namespace chromap {

src/index.cc

+27 −24

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

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

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

	const uint32_t min_seed_hit_list_index =		const uint32_t min_candidate_position_list_index =
	seed_hit_list_indices[min_seed_hit.list_index];		candidate_position_list_indices[min_candidate_position.list_index];
	const std::vector<uint64_t> &min_sorted_seed_hit_list =		const std::vector<uint64_t> &min_sorted_candidate_position_list =
	sorted_seed_hit_lists[min_seed_hit.list_index];		sorted_candidate_position_lists[min_candidate_position.list_index];
	if (min_seed_hit_list_index < min_sorted_seed_hit_list.size()) {		if (min_candidate_position_list_index <
	heap.emplace(min_seed_hit.list_index,		min_sorted_candidate_position_list.size()) {
	min_sorted_seed_hit_list[min_seed_hit_list_index]);		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());		positive_candidate_position_lists[mi].end());
	}		}
	}		}
	HeapMergeSeedHitLists(positive_candidate_position_lists,		HeapMergeCandidatePositionLists(positive_candidate_position_lists,
	positive_candidate_positions);		positive_candidate_positions);
	HeapMergeSeedHitLists(negative_candidate_position_lists,		HeapMergeCandidatePositionLists(negative_candidate_position_lists,
	negative_candidate_positions);		negative_candidate_positions);
	} else {		} else {
	std::sort(positive_candidate_positions.begin(),		std::sort(positive_candidate_positions.begin(),

src/index.h

+3 −3

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

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

	uint64_t GenerateCandidatePositionForSingleSeedHit(		uint64_t GenerateCandidatePositionForSingleSeedHit(
	uint64_t reference_seed_hit, uint64_t read_seed_hit) const;		uint64_t reference_seed_hit, uint64_t read_seed_hit) const;

src/utils.h

+4 −4

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

	// Only used in Index to merge sorted seed hit lists using heap.		// Only used in Index to merge sorted candidate position lists using heap.
	struct SeedHitInList {		struct CandidatePositionWithListIndex {
	uint32_t list_index;		uint32_t list_index;
	uint64_t position;		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) {}		: 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.		// The inversed direction is to make a min-heap.
	return position > h.position;		return position > h.position;
	}		}

Admin message