[mlpack-svn] r10463 - in mlpack/trunk/src/mlpack/methods: emst neighbor_search neighbor_search/sort_policies
fastlab-svn at coffeetalk-1.cc.gatech.edu
fastlab-svn at coffeetalk-1.cc.gatech.edu
Wed Nov 30 00:37:01 EST 2011
Author: rcurtin
Date: 2011-11-30 00:37:00 -0500 (Wed, 30 Nov 2011)
New Revision: 10463
Modified:
mlpack/trunk/src/mlpack/methods/emst/dtb.hpp
mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search.hpp
mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search_impl.hpp
mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/furthest_neighbor_sort_impl.hpp
mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/nearest_neighbor_sort_impl.hpp
Log:
Update uses of BinarySpaceTree to conform to new API.
Modified: mlpack/trunk/src/mlpack/methods/emst/dtb.hpp
===================================================================
--- mlpack/trunk/src/mlpack/methods/emst/dtb.hpp 2011-11-30 05:36:37 UTC (rev 10462)
+++ mlpack/trunk/src/mlpack/methods/emst/dtb.hpp 2011-11-30 05:37:00 UTC (rev 10463)
@@ -263,77 +263,77 @@
double incoming_distance)
{
// Check for a distance prune.
- if (query_node->stat().max_neighbor_distance() < incoming_distance)
+ if (query_node->Stat().max_neighbor_distance() < incoming_distance)
{
// Pruned by distance.
number_distance_prunes_++;
}
// Check for a component prune.
- else if ((query_node->stat().component_membership() >= 0)
- && (query_node->stat().component_membership() ==
- reference_node->stat().component_membership()))
+ else if ((query_node->Stat().component_membership() >= 0)
+ && (query_node->Stat().component_membership() ==
+ reference_node->Stat().component_membership()))
{
// Pruned by component membership.
- mlpack::Log::Assert(reference_node->stat().component_membership() >= 0);
- mlpack::Log::Info << query_node->stat().component_membership()
+ mlpack::Log::Assert(reference_node->Stat().component_membership() >= 0);
+ mlpack::Log::Info << query_node->Stat().component_membership()
<< "q mem\n";
- mlpack::Log::Info << reference_node->stat().component_membership()
+ mlpack::Log::Info << reference_node->Stat().component_membership()
<< "r mem\n";
number_component_prunes_++;
}
- else if (query_node->is_leaf() && reference_node->is_leaf()) // Base case.
+ else if (query_node->IsLeaf() && reference_node->IsLeaf()) // Base case.
{
- double new_bound = ComputeBaseCase_(query_node->begin(),
- query_node->end(), reference_node->begin(), reference_node->end());
+ double new_bound = ComputeBaseCase_(query_node->Begin(),
+ query_node->End(), reference_node->Begin(), reference_node->End());
- query_node->stat().set_max_neighbor_distance(new_bound);
+ query_node->Stat().set_max_neighbor_distance(new_bound);
}
- else if (query_node->is_leaf()) // Other recursive calls.
+ else if (query_node->IsLeaf()) // Other recursive calls.
{
// Recurse on reference_node only.
number_r_recursions_++;
double left_dist =
- query_node->bound().MinDistance(reference_node->left()->bound());
+ query_node->Bound().MinDistance(reference_node->Left()->Bound());
double right_dist =
- query_node->bound().MinDistance(reference_node->right()->bound());
+ query_node->Bound().MinDistance(reference_node->Right()->Bound());
mlpack::Log::Assert(left_dist >= 0.0);
mlpack::Log::Assert(right_dist >= 0.0);
if (left_dist < right_dist)
{
- ComputeNeighborsRecursion_(query_node, reference_node->left(),
+ ComputeNeighborsRecursion_(query_node, reference_node->Left(),
left_dist);
- ComputeNeighborsRecursion_(query_node, reference_node->right(),
+ ComputeNeighborsRecursion_(query_node, reference_node->Right(),
right_dist);
}
else
{
- ComputeNeighborsRecursion_(query_node, reference_node->right(),
+ ComputeNeighborsRecursion_(query_node, reference_node->Right(),
right_dist);
- ComputeNeighborsRecursion_(query_node, reference_node->left(),
+ ComputeNeighborsRecursion_(query_node, reference_node->Left(),
left_dist);
}
}
- else if (reference_node->is_leaf())
+ else if (reference_node->IsLeaf())
{
// Recurse on query_node only.
number_q_recursions_++;
double left_dist =
- query_node->left()->bound().MinDistance(reference_node->bound());
+ query_node->Left()->Bound().MinDistance(reference_node->Bound());
double right_dist =
- query_node->right()->bound().MinDistance(reference_node->bound());
+ query_node->Right()->Bound().MinDistance(reference_node->Bound());
- ComputeNeighborsRecursion_(query_node->left(), reference_node, left_dist);
- ComputeNeighborsRecursion_(query_node->right(), reference_node,
+ ComputeNeighborsRecursion_(query_node->Left(), reference_node, left_dist);
+ ComputeNeighborsRecursion_(query_node->Right(), reference_node,
right_dist);
// Update query_node's stat.
- query_node->stat().set_max_neighbor_distance(
- std::max(query_node->left()->stat().max_neighbor_distance(),
- query_node->right()->stat().max_neighbor_distance()));
+ query_node->Stat().set_max_neighbor_distance(
+ std::max(query_node->Left()->Stat().max_neighbor_distance(),
+ query_node->Right()->Stat().max_neighbor_distance()));
}
else
@@ -341,49 +341,49 @@
// Recurse on both.
number_both_recursions_++;
- double left_dist = query_node->left()->bound().MinDistance(
- reference_node->left()->bound());
- double right_dist = query_node->left()->bound().MinDistance(
- reference_node->right()->bound());
+ double left_dist = query_node->Left()->Bound().MinDistance(
+ reference_node->Left()->Bound());
+ double right_dist = query_node->Left()->Bound().MinDistance(
+ reference_node->Right()->Bound());
if (left_dist < right_dist)
{
- ComputeNeighborsRecursion_(query_node->left(), reference_node->left(),
+ ComputeNeighborsRecursion_(query_node->Left(), reference_node->Left(),
left_dist);
- ComputeNeighborsRecursion_(query_node->left(), reference_node->right(),
+ ComputeNeighborsRecursion_(query_node->Left(), reference_node->Right(),
right_dist);
}
else
{
- ComputeNeighborsRecursion_(query_node->left(), reference_node->right(),
+ ComputeNeighborsRecursion_(query_node->Left(), reference_node->Right(),
right_dist);
- ComputeNeighborsRecursion_(query_node->left(), reference_node->left(),
+ ComputeNeighborsRecursion_(query_node->Left(), reference_node->Left(),
left_dist);
}
- left_dist = query_node->right()->bound().MinDistance(
- reference_node->left()->bound());
- right_dist = query_node->right()->bound().MinDistance(
- reference_node->right()->bound());
+ left_dist = query_node->Right()->Bound().MinDistance(
+ reference_node->Left()->Bound());
+ right_dist = query_node->Right()->Bound().MinDistance(
+ reference_node->Right()->Bound());
if (left_dist < right_dist)
{
- ComputeNeighborsRecursion_(query_node->right(), reference_node->left(),
+ ComputeNeighborsRecursion_(query_node->Right(), reference_node->Left(),
left_dist);
- ComputeNeighborsRecursion_(query_node->right(), reference_node->right(),
+ ComputeNeighborsRecursion_(query_node->Right(), reference_node->Right(),
right_dist);
}
else
{
- ComputeNeighborsRecursion_(query_node->right(), reference_node->right(),
+ ComputeNeighborsRecursion_(query_node->Right(), reference_node->Right(),
right_dist);
- ComputeNeighborsRecursion_(query_node->right(), reference_node->left(),
+ ComputeNeighborsRecursion_(query_node->Right(), reference_node->Left(),
left_dist);
}
- query_node->stat().set_max_neighbor_distance(
- std::max(query_node->left()->stat().max_neighbor_distance(),
- query_node->right()->stat().max_neighbor_distance()));
+ query_node->Stat().set_max_neighbor_distance(
+ std::max(query_node->Left()->Stat().max_neighbor_distance(),
+ query_node->Right()->Stat().max_neighbor_distance()));
}
} // ComputeNeighborsRecursion_
@@ -465,35 +465,35 @@
*/
void CleanupHelper_(DTBTree* tree)
{
- tree->stat().set_max_neighbor_distance(DBL_MAX);
+ tree->Stat().set_max_neighbor_distance(DBL_MAX);
- if (!tree->is_leaf())
+ if (!tree->IsLeaf())
{
- CleanupHelper_(tree->left());
- CleanupHelper_(tree->right());
+ CleanupHelper_(tree->Left());
+ CleanupHelper_(tree->Right());
- if ((tree->left()->stat().component_membership() >= 0)
- && (tree->left()->stat().component_membership() ==
- tree->right()->stat().component_membership()))
+ if ((tree->Left()->Stat().component_membership() >= 0)
+ && (tree->Left()->Stat().component_membership() ==
+ tree->Right()->Stat().component_membership()))
{
- tree->stat().set_component_membership(tree->left()->stat().
+ tree->Stat().set_component_membership(tree->Left()->Stat().
component_membership());
}
}
else
{
- size_t new_membership = connections_.Find(tree->begin());
+ size_t new_membership = connections_.Find(tree->Begin());
- for (size_t i = tree->begin(); i < tree->end(); i++)
+ for (size_t i = tree->Begin(); i < tree->End(); i++)
{
if (new_membership != connections_.Find(i))
{
new_membership = -1;
- mlpack::Log::Assert(tree->stat().component_membership() < 0);
+ mlpack::Log::Assert(tree->Stat().component_membership() < 0);
return;
}
}
- tree->stat().set_component_membership(new_membership);
+ tree->Stat().set_component_membership(new_membership);
}
} // CleanupHelper_
Modified: mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search.hpp
===================================================================
--- mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search.hpp 2011-11-30 05:36:37 UTC (rev 10462)
+++ mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search.hpp 2011-11-30 05:37:00 UTC (rev 10463)
@@ -55,7 +55,7 @@
* @tparam Kernel The kernel function; see kernel::ExampleKernel.
* @tparam SortPolicy The sort policy for distances; see NearestNeighborSort.
*/
-template<typename Kernel = mlpack::metric::SquaredEuclideanDistance,
+template<typename MetricType = mlpack::metric::SquaredEuclideanDistance,
typename SortPolicy = NearestNeighborSort>
class NeighborSearch
{
@@ -89,7 +89,7 @@
arma::mat queries_;
//! Instantiation of kernel.
- Kernel kernel_;
+ MetricType kernel_;
//! Pointer to the root of the reference tree.
TreeType* reference_tree_;
@@ -136,7 +136,7 @@
* @param kernel An optional instance of the Kernel class.
*/
NeighborSearch(arma::mat& queries_in, arma::mat& references_in,
- bool alias_matrix = false, Kernel kernel = Kernel());
+ bool alias_matrix = false, MetricType kernel = MetricType());
/**
* Initialize the NeighborSearch object, passing only one dataset. In this
@@ -153,7 +153,7 @@
* @param kernel An optional instance of the Kernel class.
*/
NeighborSearch(arma::mat& references_in, bool alias_matrix = false,
- Kernel kernel = Kernel());
+ MetricType kernel = MetricType());
/**
* Delete the NeighborSearch object. The tree is the only member we are
Modified: mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search_impl.hpp
===================================================================
--- mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search_impl.hpp 2011-11-30 05:36:37 UTC (rev 10462)
+++ mlpack/trunk/src/mlpack/methods/neighbor_search/neighbor_search_impl.hpp 2011-11-30 05:37:00 UTC (rev 10463)
@@ -14,11 +14,11 @@
// We call an advanced constructor of arma::mat which allows us to alias a
// matrix (if the user has asked for that).
-template<typename Kernel, typename SortPolicy>
-NeighborSearch<Kernel, SortPolicy>::NeighborSearch(arma::mat& queries_in,
+template<typename MetricType, typename SortPolicy>
+NeighborSearch<MetricType, SortPolicy>::NeighborSearch(arma::mat& queries_in,
arma::mat& references_in,
bool alias_matrix,
- Kernel kernel) :
+ MetricType kernel) :
references_(references_in.memptr(), references_in.n_rows,
references_in.n_cols, !alias_matrix),
queries_(queries_in.memptr(), queries_in.n_rows, queries_in.n_cols,
@@ -60,10 +60,10 @@
// We call an advanced constructor of arma::mat which allows us to alias a
// matrix (if the user has asked for that).
-template<typename Kernel, typename SortPolicy>
-NeighborSearch<Kernel, SortPolicy>::NeighborSearch(arma::mat& references_in,
+template<typename MetricType, typename SortPolicy>
+NeighborSearch<MetricType, SortPolicy>::NeighborSearch(arma::mat& references_in,
bool alias_matrix,
- Kernel kernel) :
+ MetricType kernel) :
references_(references_in.memptr(), references_in.n_rows,
references_in.n_cols, !alias_matrix),
queries_(references_.memptr(), references_.n_rows, references_.n_cols,
@@ -105,8 +105,8 @@
* The tree is the only member we are responsible for deleting. The others will
* take care of themselves.
*/
-template<typename Kernel, typename SortPolicy>
-NeighborSearch<Kernel, SortPolicy>::~NeighborSearch()
+template<typename MetricType, typename SortPolicy>
+NeighborSearch<MetricType, SortPolicy>::~NeighborSearch()
{
if (reference_tree_ != query_tree_)
delete reference_tree_;
@@ -117,8 +117,8 @@
/**
* Performs exhaustive computation between two leaves.
*/
-template<typename Kernel, typename SortPolicy>
-void NeighborSearch<Kernel, SortPolicy>::ComputeBaseCase_(
+template<typename MetricType, typename SortPolicy>
+void NeighborSearch<MetricType, SortPolicy>::ComputeBaseCase_(
TreeType* query_node,
TreeType* reference_node)
{
@@ -127,8 +127,8 @@
// node->begin() is the index of the first point in the node,
// node->end is one past the last index.
- for (size_t query_index = query_node->begin();
- query_index < query_node->end(); query_index++)
+ for (size_t query_index = query_node->Begin();
+ query_index < query_node->End(); query_index++)
{
// Get the query point from the matrix.
arma::vec query_point = queries_.unsafe_col(query_index);
@@ -140,8 +140,8 @@
neighbor_distances_(knns_ - 1, query_index)))
{
// We'll do the same for the references.
- for (size_t reference_index = reference_node->begin();
- reference_index < reference_node->end(); reference_index++)
+ for (size_t reference_index = reference_node->Begin();
+ reference_index < reference_node->End(); reference_index++)
{
// Confirm that points do not identify themselves as neighbors
// in the monochromatic case.
@@ -171,152 +171,152 @@
}
// Update the upper bound for the query_node
- query_node->stat().bound_ = query_worst_distance;
+ query_node->Stat().bound_ = query_worst_distance;
} // ComputeBaseCase_
/**
* The recursive function for dual tree.
*/
-template<typename Kernel, typename SortPolicy>
-void NeighborSearch<Kernel, SortPolicy>::ComputeDualNeighborsRecursion_(
+template<typename MetricType, typename SortPolicy>
+void NeighborSearch<MetricType, SortPolicy>::ComputeDualNeighborsRecursion_(
TreeType* query_node,
TreeType* reference_node,
double lower_bound)
{
- if (SortPolicy::IsBetter(query_node->stat().bound_, lower_bound))
+ if (SortPolicy::IsBetter(query_node->Stat().bound_, lower_bound))
{
number_of_prunes_++; // Pruned by distance; the nodes cannot be any closer
return; // than the already established lower bound.
}
- if (query_node->is_leaf() && reference_node->is_leaf())
+ if (query_node->IsLeaf() && reference_node->IsLeaf())
{
ComputeBaseCase_(query_node, reference_node); // Base case: both are leaves.
return;
}
- if (query_node->is_leaf())
+ if (query_node->IsLeaf())
{
// We must keep descending down the reference node to get to a leaf.
// We'll order the computation by distance; descend in the direction of less
// distance first.
double left_distance = SortPolicy::BestNodeToNodeDistance(query_node,
- reference_node->left());
+ reference_node->Left());
double right_distance = SortPolicy::BestNodeToNodeDistance(query_node,
- reference_node->right());
+ reference_node->Right());
if (SortPolicy::IsBetter(left_distance, right_distance))
{
- ComputeDualNeighborsRecursion_(query_node, reference_node->left(),
+ ComputeDualNeighborsRecursion_(query_node, reference_node->Left(),
left_distance);
- ComputeDualNeighborsRecursion_(query_node, reference_node->right(),
+ ComputeDualNeighborsRecursion_(query_node, reference_node->Right(),
right_distance);
}
else
{
- ComputeDualNeighborsRecursion_(query_node, reference_node->right(),
+ ComputeDualNeighborsRecursion_(query_node, reference_node->Right(),
right_distance);
- ComputeDualNeighborsRecursion_(query_node, reference_node->left(),
+ ComputeDualNeighborsRecursion_(query_node, reference_node->Left(),
left_distance);
}
return;
}
- if (reference_node->is_leaf())
+ if (reference_node->IsLeaf())
{
// We must descend down the query node to get to a leaf.
double left_distance = SortPolicy::BestNodeToNodeDistance(
- query_node->left(), reference_node);
+ query_node->Left(), reference_node);
double right_distance = SortPolicy::BestNodeToNodeDistance(
- query_node->right(), reference_node);
+ query_node->Right(), reference_node);
- ComputeDualNeighborsRecursion_(query_node->left(), reference_node,
+ ComputeDualNeighborsRecursion_(query_node->Left(), reference_node,
left_distance);
- ComputeDualNeighborsRecursion_(query_node->right(), reference_node,
+ ComputeDualNeighborsRecursion_(query_node->Right(), reference_node,
right_distance);
// We need to update the upper bound based on the new upper bounds of
// the children
- double left_bound = query_node->left()->stat().bound_;
- double right_bound = query_node->right()->stat().bound_;
+ double left_bound = query_node->Left()->Stat().bound_;
+ double right_bound = query_node->Right()->Stat().bound_;
if (SortPolicy::IsBetter(left_bound, right_bound))
- query_node->stat().bound_ = right_bound;
+ query_node->Stat().bound_ = right_bound;
else
- query_node->stat().bound_ = left_bound;
+ query_node->Stat().bound_ = left_bound;
return;
}
// Neither side is a leaf; so we recurse on all combinations of both. The
// calculations are ordered by distance.
- double left_distance = SortPolicy::BestNodeToNodeDistance(query_node->left(),
- reference_node->left());
- double right_distance = SortPolicy::BestNodeToNodeDistance(query_node->left(),
- reference_node->right());
+ double left_distance = SortPolicy::BestNodeToNodeDistance(query_node->Left(),
+ reference_node->Left());
+ double right_distance = SortPolicy::BestNodeToNodeDistance(query_node->Left(),
+ reference_node->Right());
// Recurse on query_node->left() first.
if (SortPolicy::IsBetter(left_distance, right_distance))
{
- ComputeDualNeighborsRecursion_(query_node->left(), reference_node->left(),
+ ComputeDualNeighborsRecursion_(query_node->Left(), reference_node->Left(),
left_distance);
- ComputeDualNeighborsRecursion_(query_node->left(), reference_node->right(),
+ ComputeDualNeighborsRecursion_(query_node->Left(), reference_node->Right(),
right_distance);
}
else
{
- ComputeDualNeighborsRecursion_(query_node->left(), reference_node->right(),
+ ComputeDualNeighborsRecursion_(query_node->Left(), reference_node->Right(),
right_distance);
- ComputeDualNeighborsRecursion_(query_node->left(), reference_node->left(),
+ ComputeDualNeighborsRecursion_(query_node->Left(), reference_node->Left(),
left_distance);
}
- left_distance = SortPolicy::BestNodeToNodeDistance(query_node->right(),
- reference_node->left());
- right_distance = SortPolicy::BestNodeToNodeDistance(query_node->right(),
- reference_node->right());
+ left_distance = SortPolicy::BestNodeToNodeDistance(query_node->Right(),
+ reference_node->Left());
+ right_distance = SortPolicy::BestNodeToNodeDistance(query_node->Right(),
+ reference_node->Right());
// Now recurse on query_node->right().
if (SortPolicy::IsBetter(left_distance, right_distance))
{
- ComputeDualNeighborsRecursion_(query_node->right(), reference_node->left(),
+ ComputeDualNeighborsRecursion_(query_node->Right(), reference_node->Left(),
left_distance);
- ComputeDualNeighborsRecursion_(query_node->right(), reference_node->right(),
+ ComputeDualNeighborsRecursion_(query_node->Right(), reference_node->Right(),
right_distance);
}
else
{
- ComputeDualNeighborsRecursion_(query_node->right(), reference_node->right(),
+ ComputeDualNeighborsRecursion_(query_node->Right(), reference_node->Right(),
right_distance);
- ComputeDualNeighborsRecursion_(query_node->right(), reference_node->left(),
+ ComputeDualNeighborsRecursion_(query_node->Right(), reference_node->Left(),
left_distance);
}
// Update the upper bound as above
- double left_bound = query_node->left()->stat().bound_;
- double right_bound = query_node->right()->stat().bound_;
+ double left_bound = query_node->Left()->Stat().bound_;
+ double right_bound = query_node->Right()->Stat().bound_;
if (SortPolicy::IsBetter(left_bound, right_bound))
- query_node->stat().bound_ = right_bound;
+ query_node->Stat().bound_ = right_bound;
else
- query_node->stat().bound_ = left_bound;
+ query_node->Stat().bound_ = left_bound;
} // ComputeDualNeighborsRecursion_
-template<typename Kernel, typename SortPolicy>
-void NeighborSearch<Kernel, SortPolicy>::ComputeSingleNeighborsRecursion_(
+template<typename MetricType, typename SortPolicy>
+void NeighborSearch<MetricType, SortPolicy>::ComputeSingleNeighborsRecursion_(
size_t point_id,
arma::vec& point,
TreeType* reference_node,
double& best_dist_so_far)
{
- if (reference_node->is_leaf())
+ if (reference_node->IsLeaf())
{
// Base case: reference node is a leaf.
- for (size_t reference_index = reference_node->begin();
- reference_index < reference_node->end(); reference_index++)
+ for (size_t reference_index = reference_node->Begin();
+ reference_index < reference_node->End(); reference_index++)
{
// Confirm that points do not identify themselves as neighbors
// in the monochromatic case
@@ -344,9 +344,9 @@
{
// We'll order the computation by distance.
double left_distance = SortPolicy::BestPointToNodeDistance(point,
- reference_node->left());
+ reference_node->Left());
double right_distance = SortPolicy::BestPointToNodeDistance(point,
- reference_node->right());
+ reference_node->Right());
// Recurse in the best direction first.
if (SortPolicy::IsBetter(left_distance, right_distance))
@@ -355,13 +355,13 @@
number_of_prunes_++; // Prune; no possibility of finding a better point.
else
ComputeSingleNeighborsRecursion_(point_id, point,
- reference_node->left(), best_dist_so_far);
+ reference_node->Left(), best_dist_so_far);
if (SortPolicy::IsBetter(best_dist_so_far, right_distance))
number_of_prunes_++; // Prune; no possibility of finding a better point.
else
ComputeSingleNeighborsRecursion_(point_id, point,
- reference_node->right(), best_dist_so_far);
+ reference_node->Right(), best_dist_so_far);
}
else
@@ -370,13 +370,13 @@
number_of_prunes_++; // Prune; no possibility of finding a better point.
else
ComputeSingleNeighborsRecursion_(point_id, point,
- reference_node->right(), best_dist_so_far);
+ reference_node->Right(), best_dist_so_far);
if (SortPolicy::IsBetter(best_dist_so_far, left_distance))
number_of_prunes_++; // Prune; no possibility of finding a better point.
else
ComputeSingleNeighborsRecursion_(point_id, point,
- reference_node->left(), best_dist_so_far);
+ reference_node->Left(), best_dist_so_far);
}
}
}
@@ -385,8 +385,8 @@
* Computes the best neighbors and stores them in resulting_neighbors and
* distances.
*/
-template<typename Kernel, typename SortPolicy>
-void NeighborSearch<Kernel, SortPolicy>::ComputeNeighbors(
+template<typename MetricType, typename SortPolicy>
+void NeighborSearch<MetricType, SortPolicy>::ComputeNeighbors(
arma::Mat<size_t>& resulting_neighbors,
arma::mat& distances)
{
@@ -484,8 +484,8 @@
* @param neighbor Index of reference point which is being inserted.
* @param distance Distance from query point to reference point.
*/
-template<typename Kernel, typename SortPolicy>
-void NeighborSearch<Kernel, SortPolicy>::InsertNeighbor(size_t query_index,
+template<typename MetricType, typename SortPolicy>
+void NeighborSearch<MetricType, SortPolicy>::InsertNeighbor(size_t query_index,
size_t pos,
size_t neighbor,
double distance)
Modified: mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/furthest_neighbor_sort_impl.hpp
===================================================================
--- mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/furthest_neighbor_sort_impl.hpp 2011-11-30 05:36:37 UTC (rev 10462)
+++ mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/furthest_neighbor_sort_impl.hpp 2011-11-30 05:37:00 UTC (rev 10463)
@@ -18,7 +18,7 @@
{
// This is not implemented yet for the general case because the trees do not
// accept arbitrary distance metrics.
- return query_node->bound().MaxDistance(reference_node->bound());
+ return query_node->Bound().MaxDistance(reference_node->Bound());
}
template<typename TreeType>
@@ -28,7 +28,7 @@
{
// This is not implemented yet for the general case because the trees do not
// accept arbitrary distance metrics.
- return reference_node->bound().MaxDistance(point);
+ return reference_node->Bound().MaxDistance(point);
}
}; // namespace neighbor
Modified: mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/nearest_neighbor_sort_impl.hpp
===================================================================
--- mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/nearest_neighbor_sort_impl.hpp 2011-11-30 05:36:37 UTC (rev 10462)
+++ mlpack/trunk/src/mlpack/methods/neighbor_search/sort_policies/nearest_neighbor_sort_impl.hpp 2011-11-30 05:37:00 UTC (rev 10463)
@@ -18,7 +18,7 @@
{
// This is not implemented yet for the general case because the trees do not
// accept arbitrary distance metrics.
- return query_node->bound().MinDistance(reference_node->bound());
+ return query_node->Bound().MinDistance(reference_node->Bound());
}
template<typename TreeType>
@@ -28,7 +28,7 @@
{
// This is not implemented yet for the general case because the trees do not
// accept arbitrary distance metrics.
- return reference_node->bound().MinDistance(point);
+ return reference_node->Bound().MinDistance(point);
}
}; // namespace neighbor
More information about the mlpack-svn
mailing list