C++ Heap::Reserve方法代码示例

void IndexEncoding::BestNextWords(const double* p_residual, 
								  const SMatrix<double>& matDictionary, 
								  int idx_start,
								  int idx_end,
								  SMatrix<double> &mat_diff, 
								  Vector<short>& best_idx) const
{
	int m_nDimension = matDictionary.Cols();

	SMatrix<double> mat_each_diff(idx_end - idx_start, m_nDimension);

	Heap<PAIR<double> > pq;
	pq.Reserve(m_nNumBestCan);

	for (int i = idx_start; i < idx_end; i++)
	{
		const double* p_dic = matDictionary[i];

		double e = 0;
		for (int j = 0; j < m_nDimension; j++)
		{
			double d = p_residual[j] - p_dic[j];
			mat_each_diff[i - idx_start][j] = d;
			e += d * d;
		}

		if (pq.size() >= m_nNumBestCan)
		{
			const PAIR<double> &p = pq.Top();
			if (p.distance > e)
			{
				pq.popMin();

				pq.insert(PAIR<double>(i - idx_start, e));
			}
		}
		else
		{
			pq.insert(PAIR<double>(i - idx_start, e));
		}

	}

	mat_diff.AllocateSpace(m_nNumBestCan, m_nDimension);
	best_idx.AllocateSpace(m_nNumBestCan);
	for (int i = m_nNumBestCan - 1; i >= 0; i--)
	{
		PAIR<double> p;
		pq.popMin(p);
		best_idx[i] = p.index;
		memcpy(mat_diff[i], mat_each_diff[p.index], sizeof(double) * m_nDimension);
	}
}

void IndexEncoding::BestNextWordsSMart(
	const Vector<double> &vec_x_map, 
	const SMatrix<double> &matInnerProduct, 
	const short* prepresentation,
	int idx, 
	short next_idx[], 
	double next_errors[]) const
{
	Heap<PAIR<double> > pq;
	pq.Reserve(m_nNumBestCan);

	int sub_dic_size = matInnerProduct.Rows() / m_nNumberDictionaryEachPartition;

	int idx_start = idx * sub_dic_size;
	int idx_end = idx_start + sub_dic_size;

	for (int i = idx_start; i < idx_end; i++)
	{
		// compoute the relative error
		double e = -vec_x_map[i];
		const double* p_inner = matInnerProduct[i];
		for (int j = 0; j < idx; j++)
		{
			e += p_inner[prepresentation[j]];
		}
		e += 0.5 * p_inner[i];

		if (pq.size() >= m_nNumBestCan)
		{
			const PAIR<double> &p = pq.Top();
			if (p.distance > e)
			{
				pq.popMin();

				pq.insert(PAIR<double>(i, e));
			}
		}
		else
		{
			pq.insert(PAIR<double>(i, e));
		}
	}

	for (int i = m_nNumBestCan - 1; i >= 0; i--)
	{
		PAIR<double> p;
		pq.popMin(p);
		next_idx[i] = p.index;
		next_errors[i] = p.distance;
	}
}

int IndexEncoding::SolveAdditiveQuantization(const Vector<double> &vec_x_map, 
											 const SMatrix<double> &matPrecomputed, 
											 int num_dic_each_partition, 
											 short* prepresentation) const
{
	int num = 0;

	bool is_changed;
	int num_sub_centers = matPrecomputed.Rows() / num_dic_each_partition;

	SMatrix<short>* p_curr;
	SMatrix<short>* p_aux;
	p_curr = new SMatrix<short>(m_nNumBestCan, num_dic_each_partition);
	p_aux = new SMatrix<short>(m_nNumBestCan, num_dic_each_partition);

	p_curr->SetValue(-1);

	{ // find the best m_aq_candidate number of points. 
		int idx_center = 0;
		Heap<GreatPair<double> > heap;
		heap.Reserve(m_nNumBestCan);
		for (int idx_sub_cluster = 0; idx_sub_cluster < num_dic_each_partition; idx_sub_cluster++)
		{
			for (int i = 0; i < num_sub_centers; i++)
			{
				double s = residual_distance(vec_x_map, idx_center, idx_sub_cluster, 
					(*p_curr)[0], num_dic_each_partition, matPrecomputed);

				if (heap.size() < m_nNumBestCan)
				{
					heap.insert(GreatPair<double>(idx_center, s));
				}
				else
				{
					const GreatPair<double> &top = heap.Top();
					if (top.distance > s)
					{
						heap.popMin();
						heap.insert(GreatPair<double>(idx_center, s));
					}
				}
				idx_center++;
			}
		}
		SMART_ASSERT(heap.size() == m_nNumBestCan).Exit();
		for (int i = 0; i < m_nNumBestCan; i++)
		{
			GreatPair<double> v;
			heap.popMin(v);
			//PRINT << v.index << "\t" << v.distance << "\n";
			(*p_curr)[i][v.index / num_sub_centers] = v.index;
		}
		//PRINT << *p_curr << "\n";
	}

	int idx_start_center = 0;
	for (int idx_sub_cluster1 = 1; idx_sub_cluster1 < num_dic_each_partition; idx_sub_cluster1++)
	{
		priority_queue<Triplet<int, int, double>, 
			vector<Triplet<int, int, double> >,  
			LessTripletThird<int, int, double> > heap;

		for (int idx_can = 0; idx_can < m_nNumBestCan; idx_can++)
		{
			short* curr_presentation = (*p_curr)[idx_can];
			for (int idx_sub_cluster2 = 0; idx_sub_cluster2 < num_dic_each_partition; idx_sub_cluster2++)
			{
				if (curr_presentation[idx_sub_cluster2] == -1)
				{
					int idx_start_center = idx_sub_cluster2 * num_sub_centers;
					int idx_end_center = idx_start_center + num_sub_centers;
					for (int idx_center = idx_start_center; idx_center < idx_end_center; idx_center++)
					{

						double s = residual_distance(vec_x_map, idx_center, idx_sub_cluster2, curr_presentation, 
							num_dic_each_partition, matPrecomputed);

						if (heap.size() < m_nNumBestCan)
						{
							heap.push(Triplet<int, int, double>(idx_can, idx_center, s));
						}
						else
						{
							const Triplet<int, int, double> &top = heap.top();
							if (top.third > s)
							{
								heap.pop();
								heap.push(Triplet<int, int, double>(idx_can, idx_center, s));
							}
						}
					}
				}
			}
		}
		SMART_ASSERT(m_nNumBestCan == heap.size())(heap.size()).Exit();
		for (int idx_can = 0; idx_can < m_nNumBestCan; idx_can++)
		{
			const Triplet<int, int, double> &top = heap.top();
			int idx_origin_can = top.first;
			const short* p_origin = p_curr->operator[](idx_origin_can);
//.........这里部分代码省略.........