// bucket sort, but no need sort, just keep min max of every interval
int maximumGap(vector<int>& nums) {
int n = nums.size();
if (n <= 1) return 0;
auto lh = minmax_element(nums.begin(), nums.end());
int l = *lh.first, h = *lh.second;
int gap = max(1, (h-l) / (n-1));
int m = (h-l) / gap + 1;
vector<int> bucket_min(m, INT_MAX);
vector<int> bucket_max(m, INT_MIN);
for (auto num : nums) {
int k = (num-l) / gap;
bucket_min[k] = min(bucket_min[k], num);
bucket_max[k] = max(bucket_max[k], num);
}
int ans(bucket_max[0] - bucket_min[0]);
int i = 0;
while (i < m) {
int j = i+1;
while (j < m && bucket_min[j] == INT_MAX && bucket_max[j] == INT_MIN) ++j;
if (j == m) break;
ans = max(ans, bucket_min[j] - bucket_max[i]);
i = j;
}
return ans;
}
// visualise data distribution
template <typename T> Mat plotGraph(vector<T>& vals, int YRange[2], float best, float second_best)
{
auto it = minmax_element(vals.begin(), vals.end());
float scale = 1./ceil(*it.second - *it.first);
float bias = *it.first;
int rows = YRange[1] - YRange[0] + 1;
Mat image = Mat::zeros( rows+20, vals.size(), CV_8UC3 );
image.setTo(0);
for (int i = 0; i < (int)vals.size()-1; i++)
{
line(image, Point(i, rows - 1 - (vals[i] - bias)*scale*YRange[1]),
Point(i+1, rows - 1 - (vals[i+1] - bias)*scale*YRange[1]), Scalar(255, 0, 0), 1);
if (vals[i]==best)
circle( image, Point(i, rows - 1 - (vals[i] - bias)*scale*YRange[1]), 2, Scalar(0, 0, 255));
else if (vals[i]==second_best)
circle( image, Point(i, rows - 1 - (vals[i] - bias)*scale*YRange[1]), 2, Scalar(0, 255, 0));
else
circle( image, Point(i, rows - 1 - (vals[i] - bias)*scale*YRange[1]), 1, Scalar(0, 255, 255));
}
resize( image, image, Size( image.cols*2, image.rows*2 ) );
return image;
}
void RunMinMaxElementCallback()
{
{ // seq
MinMaxAlgoTest<_IterCat> _Alg(MinMax, true);
_Alg.set_pair_result(minmax_element(seq, _Alg.begin_in(), _Alg.end_in(), _Alg.callback()));
}
{ //par
MinMaxAlgoTest<_IterCat> _Alg(MinMax, true);
_Alg.set_pair_result(minmax_element(par, _Alg.begin_in(), _Alg.end_in(), _Alg.callback()));
}
{ //vec
MinMaxAlgoTest<_IterCat> _Alg(MinMax, true);
_Alg.set_pair_result(minmax_element(vec, _Alg.begin_in(), _Alg.end_in(), _Alg.callback()));
}
}
void algorithms_min_max()
{
min();
max();
minmax();
min_element();
max_element();
minmax_element();
}
void Histogram::normalize()
{
auto result = minmax_element(buskets.get(),buskets.get()+size);
double floor = *(result.second)-*(result.first);
if (floor<0.0000001)
return;
for (int i=0;i<size;i++)
{
buskets[i] = (buskets[i]-*(result.first))/floor;
}
}
void CVImage::normalize(double newMin, double newMax)
{
auto minmax = minmax_element(&data[0], &data[height * width]);
double oldMin = *minmax.first;
double oldMax = *minmax.second;
for_each(&data[0], &data[height * width], [&] (double &value) {
value = newMin + (newMax - newMin)*(value - oldMin)/(oldMax - oldMin);
});
}
typename util::detail::algorithm_result<
ExPolicy,
hpx::util::tagged_pair<
tag::min(typename traits::range_traits<Rng>::iterator_type),
tag::max(typename traits::range_traits<Rng>::iterator_type)>
>::type
minmax_element(ExPolicy && policy, Rng && rng, F && f = F(),
Proj && proj = Proj())
{
return minmax_element(std::forward<ExPolicy>(policy),
boost::begin(rng), boost::end(rng),
std::forward<F>(f), std::forward<Proj>(proj));
}
TileHolder::TileHolder(const vector<string> &files, const vector<float> &xs, const vector<float> &ys, const Size &imSz, const Size &tileSz) :
tileSz(tileSz) {
assert(files.size() == xs.size() && xs.size() == ys.size());
// for (int i = 0; i < files.size(); i++) {
// printf("%s %f %f\n", files[i].c_str(), xs[i], ys[i]);
// }
auto xMinMax = minmax_element(xs.begin(), xs.end());
float xMin = *(xMinMax.first), xMax = *(xMinMax.second);
auto yMinMax = minmax_element(ys.begin(), ys.end());
float yMin = *(yMinMax.first), yMax = *(yMinMax.second);
tl = Point2f(xMin, yMin);
// printf("abs tl: %f %f\n", tl.x, tl.y);
szInTiles.width = (int)ceil((xMax + imSz.width - tl.x) / tileSz.width);
szInTiles.height = (int)ceil((yMax + imSz.height - tl.y) / tileSz.height);
// printf("size in tiles: %u %u\n", szInTiles.width, szInTiles.height);
transBins.resize(szInTiles.area());
for (int i = 0; i < files.size(); i++) {
Point2f pos(xs[i], ys[i]);
ImData dat = {files[i], pos};
int exhuastW = 0;
while (exhuastW <= imSz.width)
{
int exhuastH = 0;
while (exhuastH <= imSz.height)
{
getBinFromPos(Point2f(xs[i] + exhuastW, ys[i] + exhuastH)).insert(dat);
exhuastH=exhuastH + tileSz.height;
}
exhuastW=exhuastW + tileSz.width;
}
}
getWeightMat(imSz, weightMat);
}
vector<vector<double>> normalizeVals(vector<vector<double>>& values)
{
vector<vector<double>> values_t = transpose(values);
for (unsigned i = 0; i < values_t.size(); i++)
{
vector<double>& v = values_t[i];
auto result = minmax_element(v.begin(), v.end());
auto minVal = v[result.first - v.begin()];
auto maxVal = v[result.second - v.begin()];
for (unsigned j = 0; j < values.size(); j++)
{
values_t[i][j] = (values_t[i][j] - minVal) / (maxVal - minVal);
}
}
return transpose(values_t);
}
inline std::pair<ForwardIter,ForwardIter>
first_min_first_max_element(ForwardIter first, ForwardIter last,
BinaryPredicate comp)
{
return minmax_element(first, last, comp);
}
inline std::pair<ForwardIter,ForwardIter>
first_min_first_max_element(ForwardIter first, ForwardIter last)
{
return minmax_element(first, last);
}
const DBSCAN::DistanceMatrix DBSCAN::calc_dist_matrix( const DBSCAN::ClusterData& C, const DBSCAN::FeaturesWeights& W )
{
DBSCAN::ClusterData cl_d = C;
omp_set_dynamic( 0 );
omp_set_num_threads( m_num_threads );
#pragma omp parallel for
for ( size_t i = 0; i < cl_d.size2(); ++i ) {
ublas::matrix_column< DBSCAN::ClusterData > col( cl_d, i );
const auto r = minmax_element( col.begin(), col.end() );
double data_min = *r.first;
double data_range = *r.second - *r.first;
if ( data_range == 0.0 ) {
data_range = 1.0;
}
const double scale = 1 / data_range;
const double min = -1.0 * data_min * scale;
col *= scale;
col.plus_assign( ublas::scalar_vector< typename ublas::matrix_column< DBSCAN::ClusterData >::value_type >( col.size(), min ) );
}
// rows x rows
DBSCAN::DistanceMatrix d_m( cl_d.size1(), cl_d.size1() );
ublas::vector< double > d_max( cl_d.size1() );
ublas::vector< double > d_min( cl_d.size1() );
omp_set_dynamic( 0 );
omp_set_num_threads( m_num_threads );
#pragma omp parallel for
for ( size_t i = 0; i < cl_d.size1(); ++i ) {
for ( size_t j = i; j < cl_d.size1(); ++j ) {
d_m( i, j ) = 0.0;
if ( i != j ) {
ublas::matrix_row< DBSCAN::ClusterData > U( cl_d, i );
ublas::matrix_row< DBSCAN::ClusterData > V( cl_d, j );
int k = 0;
for ( const auto e : ( U - V ) ) {
d_m( i, j ) += fabs( e ) * W[k++];
}
d_m( j, i ) = d_m( i, j );
}
}
const auto cur_row = ublas::matrix_row< DBSCAN::DistanceMatrix >( d_m, i );
const auto mm = minmax_element( cur_row.begin(), cur_row.end() );
d_max( i ) = *mm.second;
d_min( i ) = *mm.first;
}
m_dmin = *( min_element( d_min.begin(), d_min.end() ) );
m_dmax = *( max_element( d_max.begin(), d_max.end() ) );
m_eps = ( m_dmax - m_dmin ) * m_eps + m_dmin;
return d_m;
}
value_type min_element(P pr) const
{
return minmax_element(std::not2(pr));
}
/// Returns the value of the minimum elements in the range
value_type min_element() const
{
return minmax_element(std::greater<value_type>());
}
value_type max_element(P pr) const
{
return minmax_element(pr);
}
/// Returns the value of the maximum elements in the range
value_type max_element() const
{
return minmax_element(std::less<value_type>());
}
