void merge( const array_map<K,V,Cmp>& a ) {
if( a.size()== 0 ) return;
if( size() == 0) { *this = a; return; }
if( a.size() == 1 ) { insert( *a.begin() ); return; }
size_type ns = ( size() + a.size() + 3 ) & ~3;
data_type * nd = new data_type[ns];
data_type * d = nd;
data_type * p = m_data, *P = m_data + m_size;
data_type * q = a.m_data, *Q = a.m_data + a.size();
K last = 0;
while( p < P && q < Q ) {
if( p->first == q->first || m_cmp( p->first, q->first ) ) { last = (*d++ = *p++)->first; }
else if( m_cmp( q->first, p->first ) ) { last = (*d++ = *q++)->first; }
while( p < P && last == p->first ) ++p;
while( q < Q && last == q->first ) ++q;
}
for( ; p < P ; ++p ) {
if( last != p->first ) last = (*d++ = *p)->first;
}
for( ; q < Q ; ++q ) {
if( last != q->first ) last = (*d++ = *q)->first;
}
delete[] m_data;
m_data = nd;
m_capacity = ns;
m_size = d - nd;
}
/*!
* A negative cycle detector.
*/
bool try_improve_policy(float_t cr)
{
bool improved = false;
typename graph_traits<Graph>::vertex_iterator vi, vie;
typename graph_traits<Graph>::out_edge_iterator oei, oeie;
const float_t eps_ = FloatTraits::epsilon();
for (tie(vi, vie) = vertices(m_g); vi != vie; ++vi)
{
if (!m_badv[*vi])
{
for (tie(oei, oeie) = out_edges(*vi, m_g); oei != oeie; ++oei)
{
vertex_t t = target(*oei, m_g);
//Current distance from *vi to some vertex
float_t dis_ = m_ew1m[*oei] - m_ew2m[*oei] * cr + m_dm[t];
if ( m_cmp(m_dm[*vi] + eps_, dis_) )
{
improve_policy(*vi, *oei);
m_dm[*vi] = dis_;
improved = true;
}
}
}
else
{
float_t dis_ = m_bound - cr + m_dm[m_sink];
if ( m_cmp(m_dm[*vi] + eps_, dis_) )
{
m_dm[*vi] = dis_;
}
}
}
return improved;
}
size_type find_pos( K t ) const {
if( size() == 0 ) return 0;
typedef size_type pos;
pos a = 0;
pos b = m_size - 1;
while(1) {
if( !m_cmp( m_data[a].first, t ) ) return a;
if( !m_cmp( t, m_data[b].first ) )
return ( m_cmp( m_data[b].first, t ) ? m_size : b );
pos x = (a + b + 1)/2;
if( m_cmp( t, m_data[x].first ) ) { if( b == x ) return b; b = x; }
else if( m_cmp( m_data[x].first, t ) ) { if( a == x ) return a; a = x; }
else return x;
}
}
void erase( const array_map<K,V,Cmp>& t ) {
iterator i = begin(), I = end();
const_iterator j = t.begin(), J = t.end();
data_type* x = new data_type[ capacity() ], *X = x;
while( i != I && j != J ) {
if( m_cmp( i->first, j->first ) ) *X++ = *i++;
else if( m_cmp( j->first, i->first ) ) ++j;
else /* *i==*j */ ++i, ++j;
}
if( x != X ) {
while( i != I ) *X++ = *i++;
delete[] m_data;
m_data = x;
m_size = X - x;
}
else delete[] x;
}
bool LocaleBasedItemSorting::operator()(const MPD::Item &a, const MPD::Item &b) const
{
bool result = false;
if (a.type() == b.type())
{
switch (m_sort_mode)
{
case SortMode::Name:
switch (a.type())
{
case MPD::Item::Type::Directory:
result = m_cmp(a.directory().path(), b.directory().path());
break;
case MPD::Item::Type::Playlist:
result = m_cmp(a.playlist().path(), b.playlist().path());
break;
case MPD::Item::Type::Song:
result = m_cmp(a.song(), b.song());
break;
}
break;
case SortMode::CustomFormat:
switch (a.type())
{
case MPD::Item::Type::Directory:
result = m_cmp(a.directory().path(), b.directory().path());
break;
case MPD::Item::Type::Playlist:
result = m_cmp(a.playlist().path(), b.playlist().path());
break;
case MPD::Item::Type::Song:
result = m_cmp(Format::stringify<char>(Config.browser_sort_format, &a.song()),
Format::stringify<char>(Config.browser_sort_format, &b.song()));
break;
}
break;
case SortMode::ModificationTime:
switch (a.type())
{
case MPD::Item::Type::Directory:
result = a.directory().lastModified() > b.directory().lastModified();
break;
case MPD::Item::Type::Playlist:
result = a.playlist().lastModified() > b.playlist().lastModified();
break;
case MPD::Item::Type::Song:
result = a.song().getMTime() > b.song().getMTime();
break;
}
break;
case SortMode::NoOp:
throw std::logic_error("can't sort with NoOp sorting mode");
}
}
else
result = a.type() < b.type();
return result;
}
bool LocaleBasedItemSorting::operator()(const MPD::Item &a, const MPD::Item &b) const
{
bool result = false;
if (a.type == b.type)
{
switch (a.type)
{
case MPD::itDirectory:
result = m_cmp(getBasename(a.name), getBasename(b.name));
break;
case MPD::itPlaylist:
result = m_cmp(a.name, b.name);
break;
case MPD::itSong:
switch (m_sort_mode)
{
case SortMode::Name:
result = m_cmp(*a.song, *b.song);
break;
case SortMode::ModificationTime:
result = a.song->getMTime() > b.song->getMTime();
break;
case SortMode::CustomFormat:
result = m_cmp(a.song->toString(Config.browser_sort_format, Config.tags_separator),
b.song->toString(Config.browser_sort_format, Config.tags_separator));
break;
case SortMode::NoOp:
throw std::logic_error("can't sort with NoOp sorting mode");
}
break;
}
}
else
result = a.type < b.type;
return result;
}
/*!
* \param sv - vertex that belongs to a cycle in the policy graph.
*/
float_t cycle_ratio(vertex_t sv)
{
if (sv == m_sink) return m_bound;
std::pair<float_t, float_t> sums_(float_t(0), float_t(0));
vertex_t v = sv;
critical_cycle_t cc;
do
{
store_critical_edge(m_policy[v], cc);
sums_.first += m_ew1m[m_policy[v]];
sums_.second += m_ew2m[m_policy[v]];
v = target(m_policy[v], m_g);
}
while (v != sv);
float_t cr = sums_.first / sums_.second;
if ( m_cmp(m_cr, cr) )
{
m_cr = cr;
store_critical_cycle(cc);
}
return cr;
}
/*!
* \return maximum/minimum_{for all cycles C}
* [sum_{e in C} w1(e)] / [sum_{e in C} w2(e)],
* or FloatTraits::infinity() if graph has no cycles.
*/
float_t ocr_howard()
{
construct_policy_graph();
int k = 0;
float_t mcr = 0;
do
{
mcr = policy_mcr();
++k;
}
while (try_improve_policy(mcr) && k < 100); //To avoid infinite loop
const float_t eps_ = -0.00000001 * cmp_props_t::multiplier;
if (m_cmp(mcr, m_bound + eps_))
{
return FloatTraits::infinity();
}
else
{
return mcr;
}
}
int RegionState::KeyCmp::operator() (const Key& lhs, const Key& rhs) const {
Region::const_iterator lit = lhs.begin();
const Region::const_iterator lend = rhs.end();
Region::const_iterator rit = rhs.begin();
const Region::const_iterator rend = rhs.end();
while (lit != lend && rit != rend) {
const ClosureState* lstate = *lit;
const ClosureState* rstate = *rit;
const int cmp = m_cmp(ClosureState::getKey(lstate),
ClosureState::getKey(rstate));
if (cmp < 0)
return -1;
if (cmp > 0)
return 1;
++lit;
++rit;
}
if (lit != lend)
return 1;
if (rit != rend)
return -1;
return 0;
}
/*!
* Finds the optimal cycle ratio of the policy graph
*/
float_t policy_mcr()
{
std::fill(m_col_bfs.begin(), m_col_bfs.end(), my_white);
color_map_t vcm_ = color_map_t(m_col_bfs.begin(), m_vim);
typename graph_traits<Graph>::vertex_iterator uv_itr, vie;
tie(uv_itr, vie) = vertices(m_g);
float_t mcr = m_bound;
while ( (uv_itr = std::find_if(uv_itr, vie,
bind(std::equal_to<my_color_type>(),
my_white,
bind(&color_map_t::operator[], vcm_, _1)
)
)
) != vie )
///While there are undiscovered vertices
{
vertex_t gv = find_cycle_vertex(*uv_itr);
float_t cr = cycle_ratio(gv) ;
mcr_bfv(gv, cr, vcm_);
if ( m_cmp(mcr, cr) ) mcr = cr;
++uv_itr;
}
return mcr;
}
