bool thread_pool::get_free_queue(queue_ptr* out_queue) const
{
auto finded = std::find_if(queues.rbegin(), queues.rend(), [](const std::pair<queue::priority, queue_ptr>& iterator)
{
return !iterator.second->is_running;
});
bool is_free_queue_exist = (finded != queues.rend());
if (is_free_queue_exist)
*out_queue = finded->second;
return is_free_queue_exist;
}
void inventory_selector::remove_dropping_items( player &u ) const
{
// We iterate backwards because deletion will invalidate later indices.
for( auto a = dropping.rbegin(); a != dropping.rend(); ++a ) {
if( a->first < 0 ) { // weapon or armor, handled separately
continue;
}
const int count = a->second;
item &tmpit = u.inv.find_item( a->first );
if( tmpit.count_by_charges() ) {
long charges = tmpit.charges;
if( count != -1 && count < charges ) {
tmpit.charges -= count;
} else {
u.inv.remove_item( a->first );
}
} else {
size_t max_count = u.inv.const_stack( a->first ).size();
if( count != -1 && ( size_t )count < max_count ) {
max_count = count;
}
for( size_t i = 0; i < max_count; i++ ) {
u.inv.remove_item( a->first );
}
}
}
}
string replace_map( const std::map< std::string, std::string > &replacements ) const
{
string out;
for( size_t i = 0; i < this->size(); )
{
bool found = false;
size_t match_length = 0;
std::map< std::string, std::string >::const_reverse_iterator it;
for( it = replacements.rbegin(); !found && it != replacements.rend(); ++it )
{
const std::string &target = it->first;
const std::string &replacement = it->second;
if( match_length != target.size() )
match_length = target.size();
if( this->size() - i >= target.size() )
if( !std::memcmp( &this->at(int(i)), &target.at(0), (int)match_length ) )
{
i += target.size();
out += replacement;
found = true;
}
}
if( !found )
out += this->at(int(i++));
}
return out;
}
/**
* Get the computed average speed
* @param thr_id int (-1 for all threads)
*/
double stats_get_speed(int thr_id, double def_speed)
{
uint64_t gpu = thr_id;//device_map[thr_id];
const uint64_t keymsk = 0xffULL; // last u8 is the gpu
double speed = 0.0;
int records = 0;
std::map<uint64_t, stats_data>::reverse_iterator i = tlastscans.rbegin();
while (i != tlastscans.rend() && records < opt_statsavg)
{
if (!i->second.ignored)
if (thr_id == -1 || (keymsk & i->first) == gpu) {
if (i->second.hashcount > 1000) {
speed += i->second.hashrate;
records++;
// applog(LOG_BLUE, "%d %x %.1f", thr_id, i->second.thr_id, i->second.hashrate);
}
}
++i;
}
if (records)
speed /= (double)(records);
else
speed = def_speed;
if (thr_id == -1)
speed *= (double)(opt_n_threads);
return speed;
}
uint32_t FileWriterI::close() {
if (baseOutfile == NULL) {
WARNING << "ops::msole::FileWriterI::close() : file already closed";
return RET_ERR;
}
// close all opened files.
vector <GsfOutput*> :: iterator iter;
for ( uint32_t i = 0 ; i < openFileHandler.size() ; i++) {
GsfOutput * output = openFileHandler[i];
if (output != NULL) {
gsf_output_close (GSF_OUTPUT (output));
g_object_unref (G_OBJECT (output));
}
}
openFileHandler.clear();
// close all opened directories.
map <std::string, GsfOutput*> :: reverse_iterator rIter;
for ( rIter = openDirList.rbegin( ) ; rIter != openDirList.rend( ) ; rIter++) {
GsfOutput * output = openDirList[rIter->first];
gsf_output_close (GSF_OUTPUT (output));
g_object_unref (G_OBJECT (output));
}
openDirList.clear();
baseOutfile = NULL;
DEBUG << "ops::msole::FileWriterI::close() : file closed";
return RET_OK;
}
int solve(const int x,
std::map<int, std::vector<int> >& dataset)
{
int result = 1;
std::map<int, std::vector<int> >::reverse_iterator it = dataset.rbegin();
for(; it != dataset.rend(); ++it) {
bool isIncludeF = false;
// each vecotr element
for (int j = 0; j < (*it).second.size(); ++j) {
// std::cout << (*it).first << " " << (*it).second[j] << std::endl;
if (((*it).second)[j] == x) {
isIncludeF = true;
break;
}
}
if (isIncludeF) { break; }
++result;
}
return result;
}
void printMap(const std::map<T, T>& m, std::ostream& s = std::cout)
{
for (typename std::map<T, T>::const_reverse_iterator it = m.rbegin(); it != m.rend(); ++it)
{
if (it != m.rbegin())
s << " ";
s << it->first << " " << it->second;
}
s << "\n";
}
static inline void coeffsToDescendingWeights(std::map<unsigned int,unsigned int>& multiSet, unsigned int weights[][2]) {
std::map<unsigned int, unsigned int>::reverse_iterator rit;
int i = 0;
for ( rit=multiSet.rbegin() ; rit != multiSet.rend(); rit++ ) {
weights[i][0] = (*rit).first;
weights[i][1] = (*rit).second;
if(i>0) assert(weights[i-1][0]>weights[i][0]); //For debuging prpous only
i++;
}
}
/**
* Export data for api calls
*/
int hashlog_get_history(struct hashlog_data *data, int max_records)
{
int records = 0;
std::map<uint64_t, hashlog_data>::reverse_iterator it = tlastshares.rbegin();
while (it != tlastshares.rend() && records < max_records) {
memcpy(&data[records], &(it->second), sizeof(struct hashlog_data));
data[records].nonce = LO_DWORD(it->first);
data[records].njobid = (uint32_t) HI_DWORD(it->first);
records++;
++it;
}
return records;
}
void LockMythXDisplays(bool lock)
{
if (lock)
{
std::map<Display*, MythXDisplay*>::iterator it;
for (it = xdisplays.begin(); it != xdisplays.end(); ++it)
it->second->Lock();
}
else
{
std::map<Display*, MythXDisplay*>::reverse_iterator it;
for (it = xdisplays.rbegin(); it != xdisplays.rend(); ++it)
it->second->Unlock();
}
}
/**
* Export data for api calls
*/
int stats_get_history(int thr_id, struct stats_data *data, int max_records)
{
const uint64_t gpu = device_map[thr_id];
const uint64_t keymsk = 0xffULL; // last u8 is the gpu
int records = 0;
std::map<uint64_t, stats_data>::reverse_iterator i = tlastscans.rbegin();
while (i != tlastscans.rend() && records < max_records)
{
if (!i->second.ignored)
if (thr_id == -1 || (keymsk & i->first) == gpu) {
memcpy(&data[records], &(i->second), sizeof(struct stats_data));
records++;
}
++i;
}
return records;
}
void EmployeeListDialog::ShowEmployeeList( std::map<int, Employee*> &itsEmployees )
{
QTableWidget *tableWidget = this->ui->tableWidgetEmployeeList;
int count = 0;
for ( std::map<int, Employee *>::reverse_iterator it = itsEmployees.rbegin();
it != itsEmployees.rend();
++it ) {
Employee *e = it->second;
QString strID;
tableWidget->setItem(count,0,new QTableWidgetItem(QString::number(e->GetEmpId(), 10)));
tableWidget->setItem(count,1,new QTableWidgetItem(e->GetName().c_str()));
tableWidget->setItem(count,2,new QTableWidgetItem(e->GetAddress().c_str()));
tableWidget->setItem(count,3,new QTableWidgetItem("null"));
++count;
}
tableWidget->show();
}
void Day62App::draw()
{
gl::setMatrices(mCam);
gl::clear( Color( 0.0, 0.0, 0.0 ) );
//ROTATE THE CAMERA AROUND THE CENTRE OF THE SCENE
mCam.setEyePoint(vec3(15 * cos(theta), 0., 15*sin(theta)));
mCam.lookAt(vec3(0));
int i = 0;
for(std::map<float,glm::vec3>::reverse_iterator it = sorted.rbegin(); it != sorted.rend(); ++it)
{
gl::ScopedMatrices push;
gl::translate(it->second);
//gl::rotate(angleAxis(toRadians(mRotations[i]), vec3(0.,1.,0)));
mBatch->draw();
i++;
}
saveGif();
}
void createFragment_(String & fragment, const Param & param, const std::map<int, std::string>& optional_mappings = (std::map<int, std::string>()))
{
//std::cerr << "FRAGMENT: " << fragment << "\n\n";
// e.g.: -input %BASENAME[%%in].mzML
// we have to make this little detour param -> vector<String>
// to sort the param names by length, otherwise we have a
// problem with parameter substitution
// i.e., if A is a prefix of B and gets replaced first, the
// suffix of B remains and will cause trouble, e.g.: "%%out" vs. "%%out_fm"
vector<String> param_names;
param_names.reserve(param.size());
for (Param::ParamIterator it = param.begin(); it != param.end(); ++it)
{
param_names.push_back(it->name);
}
// sort by length
std::sort(param_names.begin(), param_names.end(), reverseComparator(StringSizeLess()));
// iterate through all input params and replace with values:
SignedSize allowed_percent(0); // filenames might contain '%', which are allowed to remain there (and even must remain)
for (vector<String>::iterator it = param_names.begin(); it != param_names.end(); ++it)
{
if (!fragment.hasSubstring("%%" + *it)) continue;
String s_new = paramToString_(param.getEntry(*it));
allowed_percent += s_new.length() - String(s_new).substitute("%", "").length();
//std::cerr << "IN: " << s_new << "(" << allowed_percent << "\n";
fragment.substitute("%%" + *it, s_new);
}
if (fragment.hasSubstring("%%")) throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Invalid '%%' found in '" + fragment + "' after replacing all parameters!", fragment);
// mapping replace> e.g.: %2
// do it reverse, since %10 should precede %1
for (std::map<int, std::string>::const_reverse_iterator it = optional_mappings.rbegin(); it != optional_mappings.rend(); ++it)
{
String m = String("%") + it->first;
if (fragment.hasSubstring(m)) {
writeDebug_(String("Replacing '") + m + "' in '" + fragment + "' by '" + it->second + "'\n", 10);
fragment.substitute(m, it->second);
}
}
// %TMP replace:
fragment.substitute("%TMP", File::getTempDirectory());
// %RND replace:
fragment.substitute("%RND", String(UniqueIdGenerator::getUniqueId()));
// %WORKINGDIR replace:
fragment.substitute("%WORKINGDIR", tde_.working_directory);
// %DIR% replace
{
QRegExp rx("%DIR\\[(.*)\\]");
rx.setMinimal(true);
int pos = 0;
QString t_tmp = fragment.toQString();
//std::cout << "fragment is:" << fragment << std::endl;
while ((pos = rx.indexIn(t_tmp, pos)) != -1)
{
String value = rx.cap(1); // param name (hopefully)
// replace in fragment:
QFileInfo qfi(value.toQString());
//std::cout << "match @ " << pos << " " << value << " --> " << qfi.canonicalPath() << "\n";
t_tmp = t_tmp.replace(String("%DIR[" + value + "]").toQString(), qfi.canonicalPath());
}
fragment = String(t_tmp);
//std::cout << "NEW fragment is:" << fragment << std::endl;
}
// %BASENAME% replace
{
QRegExp rx("%BASENAME\\[(.*)\\]");
rx.setMinimal(true);
int pos = 0, count = 0;
QString t_tmp = fragment.toQString();
while ((pos = rx.indexIn(t_tmp, pos)) != -1)
{
//std::cout << "match @ " << pos << "\n";
String value = rx.cap(1); // param name (hopefully)
// replace in fragment:
QFileInfo qfi(value.toQString());
//std::cout << "match @ " << pos << " " << value << " --> " << qfi.completeBaseName() << "\n";
t_tmp = t_tmp.replace(String("%BASENAME[" + value + "]").toQString(), qfi.completeBaseName());
++count;
}
// update expected count of valid '%'
allowed_percent -= (fragment.length() - String(fragment).substitute("%", "").length()) // original # of %
- (t_tmp.length() - String(t_tmp).substitute("%", "").length()) // new # of %
- count; // expected # of % due to %BASENAME
fragment = String(t_tmp);
}
SignedSize diff = (fragment.length() - String(fragment).substitute("%", "").length()) - allowed_percent;
//std::cerr << "allowed: " << allowed_percent << "\n" << "diff: " << diff << " in: " << fragment << "\n";
if (diff > 0) throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Mapping still contains '%' after substitution! Did you use % instead of %%?", fragment);
else if (diff < 0) throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Error: '%' from a filename where accidentally considered command tags! "
"This is a bug! Remove '%' from input filesnames to fix, but please report this as well!", fragment);
//std::cout << fragment << "'\n";
}
void unrender()
{
if (haloes.size() == 0) {
return;
}
// Remove expired haloes
std::map<int, effect>::iterator itor = haloes.begin();
for(; itor != haloes.end(); ++itor ) {
if(itor->second.expired()) {
deleted_haloes.insert(itor->first);
}
}
// Add the haloes marked for deletion to the invalidation set
std::set<int>::const_iterator set_itor = deleted_haloes.begin();
for(;set_itor != deleted_haloes.end(); ++set_itor) {
invalidated_haloes.insert(*set_itor);
haloes.find(*set_itor)->second.add_overlay_location();
}
// Test the multi-frame haloes whether they need an update
for(set_itor = changing_haloes.begin();
set_itor != changing_haloes.end(); ++set_itor) {
if(haloes.find(*set_itor)->second.need_update()) {
invalidated_haloes.insert(*set_itor);
haloes.find(*set_itor)->second.add_overlay_location();
}
}
// Find all halo's in a the invalidated area
size_t halo_count;
// Repeat until set of haloes in the invalidated area didn't change
// (including none found) or all existing haloes are found.
do {
halo_count = invalidated_haloes.size();
for(itor = haloes.begin(); itor != haloes.end(); ++itor) {
// Test all haloes not yet in the set
// which match one of the locations
// 以下这个if判断的目的是判断当前这个光环, 在当前"脏"格子集合中都是否有涉及到它，
// 如果有，也就是true，就认为该整条光环需要重绘。
// 修改：我去掉后面判断当前脏格子集合都是是否有小涉及到脏光环，而是不管有没有涉及到都要重绘
// 这里一方面是on_location函数要使用invalidated_locations这个我不想传的参数，
// 另外对后面后面部队下上方/右上角检查可能恰好找出个脏的格子，到时就可能造成该光环有步及脏格子
// if (invalidated_haloes.find(itor->first) == invalidated_haloes.end() && itor->second.on_location(invalidated_locations)) {
if (invalidated_haloes.find(itor->first) == invalidated_haloes.end()) {
// If found, add all locations which the halo invalidates,
// and add it to the set
itor->second.add_overlay_location();
invalidated_haloes.insert(itor->first);
}
}
} while (halo_count != invalidated_haloes.size() && halo_count != haloes.size());
if(halo_count == 0) {
return;
}
// 这是我注释掉的：
// 在以上的检查haloes中，已经把invalidated_haloes光环涉及到的格子放入此次脏格子集合，那里会进行重绘，这里就没必要恢复背景了吧
// !!!以下这个unrender不能去掉，否则光环显示不正常
// Render the haloes:
// iterate through all the haloes and invalidate if in set
for(std::map<int, effect>::reverse_iterator ritor = haloes.rbegin(); ritor != haloes.rend(); ++ritor) {
if(invalidated_haloes.find(ritor->first) != invalidated_haloes.end()) {
ritor->second.unrender();
}
}
// Really delete the haloes marked for deletion
for(set_itor = deleted_haloes.begin(); set_itor != deleted_haloes.end(); ++set_itor) {
// It can happen a deleted halo hasn't been rendered yet, invalidate them as well
new_haloes.erase(*set_itor);
changing_haloes.erase(*set_itor);
invalidated_haloes.erase(*set_itor);
haloes.erase(*set_itor);
}
deleted_haloes.clear();
}
void halo_impl::unrender(std::set<map_location> invalidated_locations)
{
if(preferences::show_haloes() == false || haloes.empty()) {
return;
}
//assert(invalidated_haloes.empty());
// Remove expired haloes
std::map<int, effect>::iterator itor = haloes.begin();
for(; itor != haloes.end(); ++itor ) {
if(itor->second.expired()) {
deleted_haloes.insert(itor->first);
}
}
// Add the haloes marked for deletion to the invalidation set
std::set<int>::const_iterator set_itor = deleted_haloes.begin();
for(;set_itor != deleted_haloes.end(); ++set_itor) {
invalidated_haloes.insert(*set_itor);
haloes.find(*set_itor)->second.add_overlay_location(invalidated_locations);
}
// Test the multi-frame haloes whether they need an update
for(set_itor = changing_haloes.begin();
set_itor != changing_haloes.end(); ++set_itor) {
if(haloes.find(*set_itor)->second.need_update()) {
invalidated_haloes.insert(*set_itor);
haloes.find(*set_itor)->second.add_overlay_location(invalidated_locations);
}
}
// Find all halo's in a the invalidated area
size_t halo_count;
// Repeat until set of haloes in the invalidated area didn't change
// (including none found) or all existing haloes are found.
do {
halo_count = invalidated_haloes.size();
for(itor = haloes.begin(); itor != haloes.end(); ++itor) {
// Test all haloes not yet in the set
// which match one of the locations
if(invalidated_haloes.find(itor->first) == invalidated_haloes.end() &&
(itor->second.location_not_known() ||
itor->second.on_location(invalidated_locations))) {
// If found, add all locations which the halo invalidates,
// and add it to the set
itor->second.add_overlay_location(invalidated_locations);
invalidated_haloes.insert(itor->first);
}
}
} while (halo_count != invalidated_haloes.size() && halo_count != haloes.size());
if(halo_count == 0) {
return;
}
// Render the haloes:
// iterate through all the haloes and invalidate if in set
for(std::map<int, effect>::reverse_iterator ritor = haloes.rbegin(); ritor != haloes.rend(); ++ritor) {
if(invalidated_haloes.find(ritor->first) != invalidated_haloes.end()) {
ritor->second.unrender();
}
}
// Really delete the haloes marked for deletion
for(set_itor = deleted_haloes.begin(); set_itor != deleted_haloes.end(); ++set_itor) {
// It can happen a deleted halo hasn't been rendered yet, invalidate them as well
new_haloes.erase(*set_itor);
changing_haloes.erase(*set_itor);
invalidated_haloes.erase(*set_itor);
haloes.erase(*set_itor);
}
deleted_haloes.clear();
}
int main()
{
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
std::map<int, double>::iterator i;
i = m.begin();
std::map<int, double>::const_iterator k = i;
assert(i == k);
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
i->second = 2.5;
assert(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.cbegin(), m.cend()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
assert(std::distance(m.crbegin(), m.crend()) == m.size());
std::map<int, double>::const_iterator i;
i = m.begin();
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
}
}
#if __cplusplus >= 201103L || defined(_LIBCPP_MSVC)
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
std::map<int, double, std::less<int>, min_allocator<V>>::iterator i;
i = m.begin();
std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
assert(i == k);
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
i->second = 2.5;
assert(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.cbegin(), m.cend()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
assert(std::distance(m.crbegin(), m.crend()) == m.size());
std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
i = m.begin();
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
}
}
#endif
#if _LIBCPP_STD_VER > 11
{ // N3644 testing
typedef std::map<int, double> C;
C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1;
C::const_iterator cii{};
assert ( ii1 == ii2 );
assert ( ii1 == ii4 );
assert (!(ii1 != ii2 ));
assert ( (ii1 == cii ));
assert ( (cii == ii1 ));
assert (!(ii1 != cii ));
assert (!(cii != ii1 ));
}
#endif
}
void assign(K const& keyBegin, K const& keyEnd, const V& val) {
// TODO:
// Implement this function.
// Your implementation is graded by these criteria in this order:
// - correctness (of course): In particular, pay attention to the validity of iterators. It is illegal to dereference
// end iterators. Consider using a checking STL implementation such as the one shipped with Visual C++.
// - simplicity: simple code is easy to understand and maintain, which is important in large projects.
// To write a simple solution, you need to exploit the structure of the problem.
// Use functions of std::map wherever you can.
// - running time: Imagine your implementation is part of a library, so it should be big-O optimal.
// In addition,
// * do not make big-O more operations on K and V than necessary, because you
// do not know how fast operations on K/V are; remember that constructions, destructions and assignments
// are operations as well.
// * do not make more than two operations of amortized O(log N), in contrast to O(1), running time, where N is the number of elements in m_map.
// Any operation that needs to find a position in the map "from scratch", without being given a nearby position, is such an operation.
// Otherwise favor simplicity over minor speed improvements.
// - time to turn in the solution: you should not take longer than a day, and you may be faster.
// But don't rush, I would not give you this assignment if it were trivial.
//
// You must develop the solution yourself. You may not let others help you or search for existing solutions. Of course
// you may use any documentation of the C++ language or the C++ Standard Library.
// Do not give your solution to others or make it public. It will entice others into
// sending in plagiarized solutions.
if (!(keyBegin < keyEnd)) return;
typename std::map<K, V>::iterator previousNextRangeStart, next;
typename std::map<K, V>::reverse_iterator rnext;
previousNextRangeStart = m_map.lower_bound(keyEnd);
if (previousNextRangeStart == m_map.end()) { // previous Key is up to the end of map
previousNextRangeStart--;
V previousValue;
if ((*previousNextRangeStart).first < keyBegin) { // previous Key is before new range
rnext = m_map.rbegin();
if (rnext != m_map.rend()) {
previousValue = (*rnext).second;
m_map.insert(std::make_pair(keyBegin, val));
m_map.insert(std::make_pair(keyEnd, previousValue));
}
} else { // previous Key is between new range
previousValue = (*previousNextRangeStart).second;
if ((*previousNextRangeStart).first == keyBegin) {
m_map.erase(previousNextRangeStart);
m_map.insert(std::make_pair(keyBegin, val));
m_map.insert(std::make_pair(keyEnd, previousValue));
} else {
m_map.erase(m_map.lower_bound(keyBegin), m_map.end());
m_map.insert(std::make_pair(keyBegin, val));
m_map.insert(std::make_pair(keyEnd, previousValue));
}
}
} else {
previousNextRangeStart--;
V previousValue;
previousValue = (*previousNextRangeStart).second;
if ((*previousNextRangeStart).first == keyBegin) {
m_map.erase(previousNextRangeStart);
m_map.insert(std::make_pair(keyBegin, val));
m_map.insert(std::make_pair(keyEnd, previousValue));
} else {
m_map.insert(std::make_pair(keyBegin, val));
m_map.insert(std::make_pair(keyEnd, previousValue));
}
}
}
void CoverTree<MetricType, RootPointPolicy, StatisticType>::
DualTreeTraverser<RuleType>::PruneMap(
CoverTree& queryNode,
std::map<int, std::vector<DualCoverTreeMapEntry> >& referenceMap,
std::map<int, std::vector<DualCoverTreeMapEntry> >& childMap)
{
if (referenceMap.empty())
return; // Nothing to do.
// Copy the zero set first.
if ((*referenceMap.begin()).first == INT_MIN)
{
// Get a reference to the vector representing the entries at this scale.
std::vector<DualCoverTreeMapEntry>& scaleVector =
(*referenceMap.begin()).second;
// Before traversing all the points in this scale, sort by score.
std::sort(scaleVector.begin(), scaleVector.end());
const int thisScale = (*referenceMap.begin()).first;
childMap[thisScale].reserve(scaleVector.size());
std::vector<DualCoverTreeMapEntry>& newScaleVector = childMap[thisScale];
// Loop over each entry in the vector.
for (size_t j = 0; j < scaleVector.size(); ++j)
{
const DualCoverTreeMapEntry& frame = scaleVector[j];
// First evaluate if we can prune without performing the base case.
CoverTree<MetricType, RootPointPolicy, StatisticType>* refNode =
frame.referenceNode;
// Perform the actual scoring, after restoring the traversal info.
rule.TraversalInfo() = frame.traversalInfo;
double score = rule.Score(queryNode, *refNode);
if (score == DBL_MAX)
{
// Pruned. Move on.
++numPrunes;
continue;
}
// If it isn't pruned, we must evaluate the base case.
const double baseCase = rule.BaseCase(queryNode.Point(),
refNode->Point());
// Add to child map.
newScaleVector.push_back(frame);
newScaleVector.back().score = score;
newScaleVector.back().baseCase = baseCase;
newScaleVector.back().traversalInfo = rule.TraversalInfo();
}
// If we didn't add anything, then strike this vector from the map.
if (newScaleVector.size() == 0)
childMap.erase((*referenceMap.begin()).first);
}
typename std::map<int, std::vector<DualCoverTreeMapEntry> >::reverse_iterator
it = referenceMap.rbegin();
while ((it != referenceMap.rend()))
{
const int thisScale = (*it).first;
if (thisScale == INT_MIN) // We already did it.
break;
// Get a reference to the vector representing the entries at this scale.
std::vector<DualCoverTreeMapEntry>& scaleVector = (*it).second;
// Before traversing all the points in this scale, sort by score.
std::sort(scaleVector.begin(), scaleVector.end());
childMap[thisScale].reserve(scaleVector.size());
std::vector<DualCoverTreeMapEntry>& newScaleVector = childMap[thisScale];
// Loop over each entry in the vector.
for (size_t j = 0; j < scaleVector.size(); ++j)
{
const DualCoverTreeMapEntry& frame = scaleVector[j];
// First evaluate if we can prune without performing the base case.
CoverTree<MetricType, RootPointPolicy, StatisticType>* refNode =
frame.referenceNode;
// Perform the actual scoring, after restoring the traversal info.
rule.TraversalInfo() = frame.traversalInfo;
double score = rule.Score(queryNode, *refNode);
if (score == DBL_MAX)
{
// Pruned. Move on.
++numPrunes;
continue;
}
// If it isn't pruned, we must evaluate the base case.
const double baseCase = rule.BaseCase(queryNode.Point(),
refNode->Point());
// Add to child map.
newScaleVector.push_back(frame);
newScaleVector.back().score = score;
newScaleVector.back().baseCase = baseCase;
newScaleVector.back().traversalInfo = rule.TraversalInfo();
}
// If we didn't add anything, then strike this vector from the map.
if (newScaleVector.size() == 0)
childMap.erase((*it).first);
++it; // Advance to next scale.
}
}
int bamheap2(libmaus::util::ArgInfo const & arginfo)
{
bool const verbose = arginfo.getValue("verbose",getDefaultVerbose());
std::string const reference = arginfo.getUnparsedValue("reference",std::string());
std::string const outputprefix = arginfo.getUnparsedValue("outputprefix",std::string());
libmaus::bambam::BamAlignmentDecoderWrapper::unique_ptr_type decwrapper(
libmaus::bambam::BamMultiAlignmentDecoderFactory::construct(arginfo));
::libmaus::bambam::BamAlignmentDecoder * ppdec = &(decwrapper->getDecoder());
::libmaus::bambam::BamAlignmentDecoder & dec = *ppdec;
::libmaus::bambam::BamHeader const & header = dec.getHeader();
::libmaus::bambam::BamAlignment const & algn = dec.getAlignment();
double const damult = arginfo.getValue<double>("amult",1);
double const dcmult = arginfo.getValue<double>("cmult",1);
double const dgmult = arginfo.getValue<double>("gmult",1);
double const dtmult = arginfo.getValue<double>("tmult",1);
double const dpadmult = arginfo.getValue<double>("padmult",1);
double maxmult = 0;
maxmult = std::max(damult,maxmult);
maxmult = std::max(dcmult,maxmult);
maxmult = std::max(dgmult,maxmult);
maxmult = std::max(dtmult,maxmult);
maxmult = std::max(dpadmult,maxmult);
uint64_t const amult = std::floor((damult / maxmult) * (1ull<<16) + 0.5);
uint64_t const cmult = std::floor((dcmult / maxmult) * (1ull<<16) + 0.5);
uint64_t const gmult = std::floor((dgmult / maxmult) * (1ull<<16) + 0.5);
uint64_t const tmult = std::floor((dtmult / maxmult) * (1ull<<16) + 0.5);
uint64_t const padmult = std::floor((dpadmult / maxmult) * (1ull<<16) + 0.5);
libmaus::fastx::FastAIndex::unique_ptr_type Pindex;
libmaus::aio::CheckedInputStream::unique_ptr_type PCIS;
if ( reference.size() )
{
libmaus::fastx::FastAIndex::unique_ptr_type Tindex(
libmaus::fastx::FastAIndex::load(reference+".fai")
);
Pindex = UNIQUE_PTR_MOVE(Tindex);
libmaus::aio::CheckedInputStream::unique_ptr_type TCIS(new libmaus::aio::CheckedInputStream(reference));
PCIS = UNIQUE_PTR_MOVE(TCIS);
}
libmaus::autoarray::AutoArray<libmaus::bambam::cigar_operation> cigop;
libmaus::autoarray::AutoArray<char> bases;
int64_t prevrefid = -1;
std::string refidname = "*";
std::map< uint64_t, HeapEntry > M;
uint64_t alcnt = 0;
std::vector< std::pair<char,uint8_t> > pendinginserts;
int64_t loadedRefId = -1;
int64_t streamRefId = -1;
libmaus::autoarray::AutoArray<char> refseqbases;
ConsensusAccuracy * consacc = 0;
std::map<uint64_t,ConsensusAccuracy> Mconsacc;
typedef libmaus::util::shared_ptr<std::ostringstream>::type stream_ptr_type;
stream_ptr_type Pstream;
ConsensusAux Caux;
Caux.M['a'] = Caux.M['A'] = amult;
Caux.M['c'] = Caux.M['C'] = cmult;
Caux.M['g'] = Caux.M['G'] = gmult;
Caux.M['t'] = Caux.M['T'] = tmult;
Caux.M[padsym] = padmult;
while ( dec.readAlignment() )
{
if ( algn.isMapped() && (!algn.isQCFail()) )
{
assert ( ! pendinginserts.size() );
uint32_t const numcigop = algn.getCigarOperations(cigop);
uint64_t readpos = 0;
uint64_t refpos = algn.getPos();
uint64_t const seqlen = algn.decodeRead(bases);
uint8_t const * qual = libmaus::bambam::BamAlignmentDecoderBase::getQual(algn.D.begin());
// handle finished columns
if ( algn.getRefID() != prevrefid )
{
while ( M.size() )
{
HeapEntry & H = M.begin()->second;
if ( outputprefix.size() && (streamRefId != prevrefid) )
{
if ( Pstream )
{
std::ostringstream fnostr;
fnostr << outputprefix << "_" << header.getRefIDName(streamRefId);
libmaus::aio::PosixFdOutputStream PFOS(fnostr.str());
PFOS << ">" << header.getRefIDName(streamRefId) << '\n';
PFOS << Pstream->str() << '\n';
Pstream.reset();
}
stream_ptr_type Tstream(new std::ostringstream);
Pstream = Tstream;
streamRefId = prevrefid;
}
if ( Pindex && (loadedRefId != prevrefid) )
{
refseqbases = Pindex->readSequence(*PCIS, Pindex->getSequenceIdByName(refidname));
loadedRefId = prevrefid;
if ( Mconsacc.find(loadedRefId) == Mconsacc.end() )
Mconsacc[loadedRefId] = ConsensusAccuracy(refseqbases.size());
consacc = &(Mconsacc[loadedRefId]);
}
H.toStream(std::cout,M.begin()->first,refidname,(M.begin()->first < refseqbases.size()) ? static_cast<int>(refseqbases[M.begin()->first]) : -1,Caux,consacc,Pstream.get());
M.erase(M.begin());
}
prevrefid = algn.getRefID();
refidname = header.getRefIDName(prevrefid);
}
else
{
while ( M.size() && M.begin()->first < refpos )
{
HeapEntry & H = M.begin()->second;
if ( outputprefix.size() && (streamRefId != prevrefid) )
{
if ( Pstream )
{
std::ostringstream fnostr;
fnostr << outputprefix << "_" << header.getRefIDName(streamRefId);
libmaus::aio::PosixFdOutputStream PFOS(fnostr.str());
PFOS << ">" << header.getRefIDName(streamRefId) << '\n';
PFOS << Pstream->str() << '\n';
Pstream.reset();
}
stream_ptr_type Tstream(new std::ostringstream);
Pstream = Tstream;
streamRefId = prevrefid;
}
if ( Pindex && (loadedRefId != prevrefid) )
{
refseqbases = Pindex->readSequence(*PCIS, Pindex->getSequenceIdByName(refidname));
loadedRefId = prevrefid;
if ( Mconsacc.find(loadedRefId) == Mconsacc.end() )
Mconsacc[loadedRefId] = ConsensusAccuracy(refseqbases.size());
consacc = &(Mconsacc[loadedRefId]);
}
H.toStream(std::cout,M.begin()->first,refidname,(M.begin()->first < refseqbases.size()) ? static_cast<int>(refseqbases[M.begin()->first]) : -1,Caux,consacc,Pstream.get());
M.erase(M.begin());
}
}
for ( uint64_t ci = 0; ci < numcigop; ++ci )
{
uint64_t const ciglen = cigop[ci].second;
switch ( cigop[ci].first )
{
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CMATCH:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CEQUAL:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CDIFF:
{
if ( pendinginserts.size() )
{
M[refpos].I.push_back(pendinginserts);
pendinginserts.resize(0);
}
for ( uint64_t i = 0; i < ciglen; ++i )
{
M[refpos].V.push_back(std::make_pair(bases[readpos],qual[readpos]));
readpos++;
refpos++;
}
break;
}
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CINS:
{
for ( uint64_t i = 0; i < ciglen; ++i, ++readpos )
pendinginserts.push_back(std::make_pair(bases[readpos],qual[readpos]));
break;
}
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CDEL:
// handle pending inserts
if ( pendinginserts.size() )
{
M[refpos].I.push_back(pendinginserts);
pendinginserts.resize(0);
}
// deleting bases from the reference
for ( uint64_t i = 0; i < ciglen; ++i, ++refpos )
M[refpos].V.push_back(std::make_pair(padsym,0));
break;
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CREF_SKIP:
// handle pending inserts
if ( pendinginserts.size() )
{
M[refpos].I.push_back(pendinginserts);
pendinginserts.resize(0);
}
// skip bases on reference
for ( uint64_t i = 0; i < ciglen; ++i )
{
refpos++;
}
break;
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CSOFT_CLIP:
// skip bases on read
for ( uint64_t i = 0; i < ciglen; ++i )
{
readpos++;
}
break;
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CHARD_CLIP:
break;
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CPAD:
{
for ( uint64_t i = 0; i < ciglen; ++i, ++readpos )
pendinginserts.push_back(std::make_pair(padsym,0));
break;
}
}
}
if ( pendinginserts.size() )
{
M[refpos].I.push_back(pendinginserts);
M[refpos].iadd++;
pendinginserts.resize(0);
}
assert ( readpos == seqlen );
}
if ( verbose && ((++alcnt % (1024*1024)) == 0) )
std::cerr << "[V] " << alcnt << std::endl;
}
while ( M.size() )
{
HeapEntry & H = M.begin()->second;
if ( outputprefix.size() && (streamRefId != prevrefid) )
{
if ( Pstream )
{
std::ostringstream fnostr;
fnostr << outputprefix << "_" << header.getRefIDName(streamRefId);
libmaus::aio::PosixFdOutputStream PFOS(fnostr.str());
PFOS << ">" << header.getRefIDName(streamRefId) << '\n';
PFOS << Pstream->str() << '\n';
Pstream.reset();
}
stream_ptr_type Tstream(new std::ostringstream);
Pstream = Tstream;
streamRefId = prevrefid;
}
if ( Pindex && (loadedRefId != prevrefid) )
{
refseqbases = Pindex->readSequence(*PCIS, Pindex->getSequenceIdByName(refidname));
loadedRefId = prevrefid;
if ( Mconsacc.find(loadedRefId) == Mconsacc.end() )
Mconsacc[loadedRefId] = ConsensusAccuracy(refseqbases.size());
consacc = &(Mconsacc[loadedRefId]);
}
H.toStream(std::cout,M.begin()->first,refidname,(M.begin()->first < refseqbases.size()) ? static_cast<int>(refseqbases[M.begin()->first]) : -1,Caux,consacc,Pstream.get());
M.erase(M.begin());
}
if ( Pstream )
{
std::ostringstream fnostr;
fnostr << outputprefix << "_" << header.getRefIDName(streamRefId);
libmaus::aio::PosixFdOutputStream PFOS(fnostr.str());
PFOS << ">" << header.getRefIDName(streamRefId) << '\n';
PFOS << Pstream->str() << '\n';
Pstream.reset();
}
ConsensusAccuracy constotal;
for ( std::map<uint64_t,ConsensusAccuracy>::const_iterator ita = Mconsacc.begin(); ita != Mconsacc.end(); ++ita )
{
std::cerr << header.getRefIDName(ita->first) << "\t" << ita->second << std::endl;
std::map<uint64_t,uint64_t> const M = ita->second.depthhistogram.get();
uint64_t total = 0;
uint64_t preavg = 0;
for ( std::map<uint64_t,uint64_t>::const_iterator aita = M.begin(); aita != M.end(); ++aita )
{
total += aita->second;
preavg += aita->first * aita->second;
}
uint64_t acc = 0;
for ( std::map<uint64_t,uint64_t>::const_iterator aita = M.begin(); aita != M.end(); ++aita )
{
acc += aita->second;
std::cerr << "H[" << header.getRefIDName(ita->first) << "," << aita->first << ",+]"
<< "\t" << aita->second << "\t" << static_cast<double>(aita->second)/total
<< "\t" << acc << "\t" << static_cast<double>(acc)/total << std::endl;
}
acc = 0;
for ( std::map<uint64_t,uint64_t>::const_reverse_iterator aita = M.rbegin(); aita != M.rend(); ++aita )
{
acc += aita->second;
std::cerr << "H[" << header.getRefIDName(ita->first) << "," << aita->first << ",-]"
<< "\t" << aita->second << "\t" << static_cast<double>(aita->second)/total
<< "\t" << acc << "\t" << static_cast<double>(acc)/total << std::endl;
}
std::cerr << "H[" << header.getRefIDName(ita->first) << ",avg]\t" <<
static_cast<double>(preavg)/total << std::endl;
constotal += ita->second;
}
if ( Mconsacc.size() )
{
std::cerr << "all\t" << constotal << std::endl;
std::map<uint64_t,uint64_t> const M = constotal.depthhistogram.get();
uint64_t total = 0;
uint64_t preavg = 0;
for ( std::map<uint64_t,uint64_t>::const_iterator aita = M.begin(); aita != M.end(); ++aita )
{
total += aita->second;
preavg += aita->first * aita->second;
}
uint64_t acc = 0;
for ( std::map<uint64_t,uint64_t>::const_iterator aita = M.begin(); aita != M.end(); ++aita )
{
acc += aita->second;
std::cerr << "H[" << "all" << "," << aita->first << ",+]"
<< "\t" << aita->second << "\t" << static_cast<double>(aita->second)/total
<< "\t" << acc << "\t" << static_cast<double>(acc)/total << std::endl;
}
acc = 0;
for ( std::map<uint64_t,uint64_t>::const_reverse_iterator aita = M.rbegin(); aita != M.rend(); ++aita )
{
acc += aita->second;
std::cerr << "H[" << "all" << "," << aita->first << ",-]"
<< "\t" << aita->second << "\t" << static_cast<double>(aita->second)/total
<< "\t" << acc << "\t" << static_cast<double>(acc)/total << std::endl;
}
std::cerr << "H[all,avg]\t" << static_cast<double>(preavg) / total << std::endl;
}
return EXIT_SUCCESS;
}
ReverseTextureIterator rend ()
{
return textures.rend();
}
int tc_libcxx_containers_map_access_iterator(void)
{
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::map<int, double>::iterator i;
i = m.begin();
std::map<int, double>::const_iterator k = i;
TC_ASSERT_EXPR(i == k);
for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
{
TC_ASSERT_EXPR(i->first == j);
TC_ASSERT_EXPR(i->second == 1);
i->second = 2.5;
TC_ASSERT_EXPR(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
TC_ASSERT_EXPR(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::map<int, double>::const_iterator i;
i = m.begin();
for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
{
TC_ASSERT_EXPR(i->first == j);
TC_ASSERT_EXPR(i->second == 1);
}
}
#if TEST_STD_VER > 11
{ // N3644 testing
typedef std::map<int, double> C;
C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1;
C::const_iterator cii{};
TC_ASSERT_EXPR ( ii1 == ii2 );
TC_ASSERT_EXPR ( ii1 == ii4 );
TC_ASSERT_EXPR (!(ii1 != ii2 ));
TC_ASSERT_EXPR ( (ii1 == cii ));
TC_ASSERT_EXPR ( (cii == ii1 ));
TC_ASSERT_EXPR (!(ii1 != cii ));
TC_ASSERT_EXPR (!(cii != ii1 ));
}
#endif
TC_SUCCESS_RESULT();
return 0;
}
int main()
{
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
std::map<int, double>::iterator i;
i = m.begin();
std::map<int, double>::const_iterator k = i;
assert(i == k);
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
i->second = 2.5;
assert(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.cbegin(), m.cend()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
assert(std::distance(m.crbegin(), m.crend()) == m.size());
std::map<int, double>::const_iterator i;
i = m.begin();
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
}
}
#if __cplusplus >= 201103L
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
std::map<int, double, std::less<int>, min_allocator<V>>::iterator i;
i = m.begin();
std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
assert(i == k);
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
i->second = 2.5;
assert(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(std::distance(m.begin(), m.end()) == m.size());
assert(std::distance(m.cbegin(), m.cend()) == m.size());
assert(std::distance(m.rbegin(), m.rend()) == m.size());
assert(std::distance(m.crbegin(), m.crend()) == m.size());
std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
i = m.begin();
for (int j = 1; j <= m.size(); ++j, ++i)
{
assert(i->first == j);
assert(i->second == 1);
}
}
#endif
}
inline size_t reserveArraySpace(const OperationNode<Base>& newArray) {
size_t arraySize = newArray.getArguments().size();
if (arraySize == 0)
return 0; // nothing to do (no space required)
std::set<size_t> blackList;
const std::vector<Argument<Base> >& args = newArray.getArguments();
for (size_t i = 0; i < args.size(); i++) {
const OperationNode<Base>* argOp = args[i].getOperation();
if (argOp != nullptr && argOp->getOperationType() == CGOpCode::ArrayElement) {
const OperationNode<Base>& otherArray = *argOp->getArguments()[0].getOperation();
CPPADCG_ASSERT_UNKNOWN(_varId[otherArray] > 0); // make sure it had already been assigned space
size_t otherArrayStart = _varId[otherArray] - 1;
size_t index = argOp->getInfo()[0];
blackList.insert(otherArrayStart + index);
}
}
/**
* Find the best location for the new array
*/
std::map<size_t, size_t>::reverse_iterator it;
std::map<size_t, size_t>::reverse_iterator itBestFit = _freeArrayStartSpace.rend();
size_t bestCommonValues = 0; // the number of values likely to be the same
for (it = _freeArrayStartSpace.rbegin(); it != _freeArrayStartSpace.rend(); ++it) {
size_t start = it->first;
size_t end = it->second;
size_t space = end - start + 1;
if (space < arraySize) {
continue;
}
std::set<size_t>::const_iterator itBlack = blackList.lower_bound(start);
if (itBlack != blackList.end() && *itBlack <= end) {
continue; // cannot use this space
}
//possible candidate
if (itBestFit == _freeArrayStartSpace.rend()) {
itBestFit = it;
} else {
size_t bestSpace = itBestFit->second - itBestFit->first + 1;
size_t commonVals = 0;
for (size_t i = 0; i < arraySize; i++) {
if (isSameArrayElement(_tmpArrayValues[start + i], args[i])) {
commonVals++;
}
}
if (space < bestSpace || commonVals > bestCommonValues) {
// better fit
itBestFit = it;
bestCommonValues = commonVals;
if (bestCommonValues == arraySize) {
break; // jackpot
}
}
}
}
size_t bestStart = std::numeric_limits<size_t>::max();
if (itBestFit != _freeArrayStartSpace.rend()) {
/**
* Use available space
*/
bestStart = itBestFit->first;
size_t bestEnd = itBestFit->second;
size_t bestSpace = bestEnd - bestStart + 1;
_freeArrayStartSpace.erase(bestStart);
if (bestSpace == arraySize) {
// entire space
_freeArrayEndSpace.erase(bestEnd);
} else {
// some space left
size_t newFreeStart = bestStart + arraySize;
_freeArrayStartSpace[newFreeStart] = bestEnd;
_freeArrayEndSpace.at(bestEnd) = newFreeStart;
}
} else {
/**
* no space available, need more
*/
// check if there is some free space at the end
std::map<size_t, size_t>::iterator itEnd;
itEnd = _freeArrayEndSpace.find(_idArrayCount - 1 - 1); // IDcount - initialID - 1
if (itEnd != _freeArrayEndSpace.end()) {
// check if it can be used
size_t lastSpotStart = itEnd->second;
size_t lastSpotEnd = itEnd->first;
size_t lastSpotSize = lastSpotEnd - lastSpotStart + 1;
std::set<size_t>::const_iterator itBlack = blackList.lower_bound(lastSpotStart);
if (itBlack == blackList.end()) {
// can use this space
_freeArrayEndSpace.erase(itEnd);
_freeArrayStartSpace.erase(lastSpotStart);
_idArrayCount += arraySize - lastSpotSize;
bestStart = lastSpotStart;
}
}
if (bestStart == std::numeric_limits<size_t>::max()) {
// brand new space
size_t id = _idArrayCount;
_idArrayCount += arraySize;
bestStart = id - 1;
}
}
for (size_t i = 0; i < arraySize; i++) {
_tmpArrayValues[bestStart + i] = &args[i];
}
CPPADCG_ASSERT_UNKNOWN(_freeArrayStartSpace.size() == _freeArrayEndSpace.size());
return bestStart;
}