```// Copyright (C) 2010  Davis E. King (davis@dlib.net)
#ifndef DLIB_EDGE_LIST_GrAPHS_Hh_
#define DLIB_EDGE_LIST_GrAPHS_Hh_

#include "edge_list_graphs_abstract.h"
#include <limits>
#include <vector>
#include "../string.h"
#include "../rand.h"
#include <algorithm>
#include "sample_pair.h"
#include "ordered_sample_pair.h"

namespace dlib
{

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
void remove_duplicate_edges (
vector_type& pairs
)
{
typedef typename vector_type::value_type T;
if (pairs.size() > 0)
{
// sort pairs so that we can avoid duplicates in the loop below
std::sort(pairs.begin(), pairs.end(), &order_by_index<T>);

// now put edges into temp while avoiding duplicates
vector_type temp;
temp.reserve(pairs.size());
temp.push_back(pairs[0]);
for (unsigned long i = 1; i < pairs.size(); ++i)
{
if (pairs[i] != pairs[i-1])
{
temp.push_back(pairs[i]);
}
}

temp.swap(pairs);
}
}

// ----------------------------------------------------------------------------------------

namespace impl
{
template <typename iterator>
iterator iterator_of_worst (
iterator begin,
const iterator& end
)
/*!
ensures
- returns an iterator that points to the element in the given range
that has the biggest distance
!*/
{
double dist = begin->distance();
iterator worst = begin;
for (; begin != end; ++begin)
{
if (begin->distance() > dist)
{
dist = begin->distance();
worst = begin;
}
}

return worst;
}

}

// ----------------------------------------------------------------------------------------

template <
typename vector_type,
typename distance_function_type,
typename alloc,
typename T
>
void find_percent_shortest_edges_randomly (
const vector_type& samples,
const distance_function_type& dist_funct,
const double percent,
const unsigned long num,
const T& random_seed,
std::vector<sample_pair, alloc>& out
)
{
// make sure requires clause is not broken
DLIB_ASSERT( 0 < percent && percent <= 1 &&
num > 0,
"\t void find_percent_shortest_edges_randomly()"
<< "\n\t Invalid inputs were given to this function."
<< "\n\t samples.size(): " << samples.size()
<< "\n\t percent:        " << percent
<< "\n\t num:            " << num
);

out.clear();

if (samples.size() <= 1)
{
return;
}

std::vector<sample_pair, alloc> edges;
edges.reserve(num);

dlib::rand rnd;
rnd.set_seed(cast_to_string(random_seed));

// randomly sample a bunch of edges
for (unsigned long i = 0; i < num; ++i)
{
const unsigned long idx1 = rnd.get_random_32bit_number()%samples.size();
const unsigned long idx2 = rnd.get_random_32bit_number()%samples.size();
if (idx1 != idx2)
{
const double dist = dist_funct(samples[idx1], samples[idx2]);
if (dist < std::numeric_limits<double>::infinity())
{
edges.push_back(sample_pair(idx1, idx2, dist));
}
}
}

// now put edges into out while avoiding duplicates
if (edges.size() > 0)
{
remove_duplicate_edges(edges);

// now sort all the edges by distance and take the percent with the smallest distance
std::sort(edges.begin(), edges.end(), &order_by_distance<sample_pair>);

const unsigned long out_size = std::min<unsigned long>((unsigned long)(num*percent), edges.size());
out.assign(edges.begin(), edges.begin() + out_size);
}
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type,
typename distance_function_type,
typename alloc,
typename T
>
void find_approximate_k_nearest_neighbors (
const vector_type& samples,
const distance_function_type& dist_funct,
const unsigned long k,
unsigned long num,
const T& random_seed,
std::vector<sample_pair, alloc>& out
)
{
// make sure requires clause is not broken
DLIB_ASSERT( num > 0 && k > 0,
"\t void find_approximate_k_nearest_neighbors()"
<< "\n\t Invalid inputs were given to this function."
<< "\n\t samples.size(): " << samples.size()
<< "\n\t k:              " << k
<< "\n\t num:            " << num
);

out.clear();

if (samples.size() <= 1)
{
return;
}

// we add each edge twice in the following loop.  So multiply num by 2 to account for that.
num *= 2;

std::vector<ordered_sample_pair> edges;
edges.reserve(num);
std::vector<sample_pair, alloc> temp;
temp.reserve(num);

dlib::rand rnd;
rnd.set_seed(cast_to_string(random_seed));

// randomly sample a bunch of edges
for (unsigned long i = 0; i < num; ++i)
{
const unsigned long idx1 = rnd.get_random_32bit_number()%samples.size();
const unsigned long idx2 = rnd.get_random_32bit_number()%samples.size();
if (idx1 != idx2)
{
const double dist = dist_funct(samples[idx1], samples[idx2]);
if (dist < std::numeric_limits<double>::infinity())
{
edges.push_back(ordered_sample_pair(idx1, idx2, dist));
edges.push_back(ordered_sample_pair(idx2, idx1, dist));
}
}
}

std::sort(edges.begin(), edges.end(), &order_by_index<ordered_sample_pair>);

std::vector<ordered_sample_pair>::iterator beg, itr;
// now copy edges into temp when they aren't duplicates and also only move in the k shortest for
// each index.
itr = edges.begin();
while (itr != edges.end())
{
// first find the bounding range for all the edges connected to node itr->index1()
beg = itr;
while (itr != edges.end() && itr->index1() == beg->index1())
++itr;

// If the node has more than k edges then sort them by distance so that
// we will end up with the k best.
if (static_cast<unsigned long>(itr - beg) > k)
{
std::sort(beg, itr, &order_by_distance_and_index<ordered_sample_pair>);
}

// take the k best unique edges from the range [beg,itr)
temp.push_back(sample_pair(beg->index1(), beg->index2(), beg->distance()));
unsigned long prev_index2 = beg->index2();
++beg;
unsigned long count = 1;
for (; beg != itr && count < k; ++beg)
{
if (beg->index2() != prev_index2)
{
temp.push_back(sample_pair(beg->index1(), beg->index2(), beg->distance()));
++count;
}
prev_index2 = beg->index2();
}
}

remove_duplicate_edges(temp);
temp.swap(out);
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type,
typename distance_function_type,
typename alloc
>
void find_k_nearest_neighbors (
const vector_type& samples,
const distance_function_type& dist_funct,
const unsigned long k,
std::vector<sample_pair, alloc>& out
)
{
// make sure requires clause is not broken
DLIB_ASSERT(k > 0,
"\t void find_k_nearest_neighbors()"
<< "\n\t Invalid inputs were given to this function."
<< "\n\t samples.size(): " << samples.size()
<< "\n\t k:              " << k
);

out.clear();

if (samples.size() <= 1)
{
return;
}

using namespace impl;
std::vector<sample_pair> edges;

// Initialize all the edges to an edge with an invalid index
edges.resize(samples.size()*k,
sample_pair(samples.size(),samples.size(),std::numeric_limits<double>::infinity()));

// Hold the length for the longest edge for each node.  Initially they are all infinity.
std::vector<double> worst_dists(samples.size(), std::numeric_limits<double>::infinity());

std::vector<sample_pair>::iterator begin_i, end_i, begin_j, end_j;
begin_i = edges.begin();
end_i = begin_i + k;

// Loop over all combinations of samples.   We will maintain the iterator ranges so that
// within the inner for loop we have:
//   [begin_i, end_i) == the range in edges that contains neighbors of samples[i]
//   [begin_j, end_j) == the range in edges that contains neighbors of samples[j]
for (unsigned long i = 0; i+1 < samples.size(); ++i)
{
begin_j = begin_i;
end_j = end_i;

for (unsigned long j = i+1; j < samples.size(); ++j)
{
begin_j += k;
end_j += k;

const double dist = dist_funct(samples[i], samples[j]);

if (dist < worst_dists[i])
{
*iterator_of_worst(begin_i, end_i) = sample_pair(i, j, dist);
worst_dists[i] = iterator_of_worst(begin_i, end_i)->distance();
}

if (dist < worst_dists[j])
{
*iterator_of_worst(begin_j, end_j) = sample_pair(i, j, dist);
worst_dists[j] = iterator_of_worst(begin_j, end_j)->distance();
}
}

begin_i += k;
end_i += k;
}

// sort the edges so that duplicate edges will be adjacent
std::sort(edges.begin(), edges.end(), &order_by_index<sample_pair>);

// if the first edge is valid
if (edges[0].index1() < samples.size())
{
// now put edges into out while avoiding duplicates and any remaining invalid edges.
out.reserve(edges.size());
out.push_back(edges[0]);
for (unsigned long i = 1; i < edges.size(); ++i)
{
// if we hit an invalid edge then we can stop
if (edges[i].index1() >= samples.size())
break;

// if this isn't a duplicate edge
if (edges[i] != edges[i-1])
{
out.push_back(edges[i]);
}
}
}

}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
bool contains_duplicate_pairs (
const vector_type& pairs
)
{
typedef typename vector_type::value_type T;
vector_type temp(pairs);
std::sort(temp.begin(), temp.end(), &order_by_index<T>);

for (unsigned long i = 1; i < temp.size(); ++i)
{
// if we found a duplicate
if (temp[i-1] == temp[i])
return true;
}

return false;
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
typename enable_if_c<(is_same_type<sample_pair, typename vector_type::value_type>::value ||
is_same_type<ordered_sample_pair, typename vector_type::value_type>::value),
unsigned long>::type
max_index_plus_one (
const vector_type& pairs
)
{
if (pairs.size() == 0)
{
return 0;
}
else
{
unsigned long max_idx = 0;
for (unsigned long i = 0; i < pairs.size(); ++i)
{
if (pairs[i].index1() > max_idx)
max_idx = pairs[i].index1();
if (pairs[i].index2() > max_idx)
max_idx = pairs[i].index2();
}

return max_idx + 1;
}
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
void remove_long_edges (
vector_type& pairs,
double distance_threshold
)
{
vector_type temp;
temp.reserve(pairs.size());

// add all the pairs shorter than the given threshold into temp
for (unsigned long i = 0; i < pairs.size(); ++i)
{
if (pairs[i].distance() <= distance_threshold)
temp.push_back(pairs[i]);
}

// move temp into the output vector
temp.swap(pairs);
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
void remove_short_edges (
vector_type& pairs,
double distance_threshold
)
{
vector_type temp;
temp.reserve(pairs.size());

// add all the pairs longer than the given threshold into temp
for (unsigned long i = 0; i < pairs.size(); ++i)
{
if (pairs[i].distance() >= distance_threshold)
temp.push_back(pairs[i]);
}

// move temp into the output vector
temp.swap(pairs);
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
void remove_percent_longest_edges (
vector_type& pairs,
double percent
)
{
// make sure requires clause is not broken
DLIB_ASSERT( 0 <= percent && percent < 1,
"\t void remove_percent_longest_edges()"
<< "\n\t Invalid inputs were given to this function."
<< "\n\t percent:        " << percent
);

typedef typename vector_type::value_type T;
std::sort(pairs.begin(), pairs.end(), &order_by_distance<T>);

const unsigned long num = static_cast<unsigned long>((1.0-percent)*pairs.size());

// pick out the num shortest pairs
vector_type temp(pairs.begin(), pairs.begin() + num);

// move temp into the output vector
temp.swap(pairs);
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
void remove_percent_shortest_edges (
vector_type& pairs,
double percent
)
{
// make sure requires clause is not broken
DLIB_ASSERT( 0 <= percent && percent < 1,
"\t void remove_percent_shortest_edges()"
<< "\n\t Invalid inputs were given to this function."
<< "\n\t percent:        " << percent
);

typedef typename vector_type::value_type T;
std::sort(pairs.rbegin(), pairs.rend(), &order_by_distance<T>);

const unsigned long num = static_cast<unsigned long>((1.0-percent)*pairs.size());

// pick out the num shortest pairs
vector_type temp(pairs.begin(), pairs.begin() + num);

// move temp into the output vector
temp.swap(pairs);
}

// ----------------------------------------------------------------------------------------

template <
typename vector_type
>
bool is_ordered_by_index (
const vector_type& edges
)
{
for (unsigned long i = 1; i < edges.size(); ++i)
{
if (order_by_index(edges[i], edges[i-1]))
return false;
}
return true;
}

// ----------------------------------------------------------------------------------------

template <
typename alloc1,
typename alloc2
>
void find_neighbor_ranges (
const std::vector<ordered_sample_pair,alloc1>& edges,
std::vector<std::pair<unsigned long, unsigned long>,alloc2>& neighbors
)
{
// make sure requires clause is not broken
DLIB_ASSERT(is_ordered_by_index(edges),
"\t void find_neighbor_ranges()"
<< "\n\t Invalid inputs were given to this function"
);

// setup neighbors so that [neighbors[i].first, neighbors[i].second) is the range
// within edges that contains all node i's edges.
const unsigned long num_nodes = max_index_plus_one(edges);
neighbors.assign(num_nodes, std::make_pair(0,0));
unsigned long cur_node = 0;
unsigned long start_idx = 0;
for (unsigned long i = 0; i < edges.size(); ++i)
{
if (edges[i].index1() != cur_node)
{
neighbors[cur_node] = std::make_pair(start_idx, i);
start_idx = i;
cur_node = edges[i].index1();
}
}
if (neighbors.size() != 0)
neighbors[cur_node] = std::make_pair(start_idx, (unsigned long)edges.size());
}

// ----------------------------------------------------------------------------------------

template <
typename alloc1,
typename alloc2
>
void convert_unordered_to_ordered (
const std::vector<sample_pair,alloc1>& edges,
std::vector<ordered_sample_pair,alloc2>& out_edges
)
{
out_edges.clear();
out_edges.reserve(edges.size()*2);
for (unsigned long i = 0; i < edges.size(); ++i)
{
out_edges.push_back(ordered_sample_pair(edges[i].index1(), edges[i].index2(), edges[i].distance()));
if (edges[i].index1() != edges[i].index2())
out_edges.push_back(ordered_sample_pair(edges[i].index2(), edges[i].index1(), edges[i].distance()));
}
}

// ----------------------------------------------------------------------------------------

}

#endif // DLIB_EDGE_LIST_GrAPHS_Hh_

```