seconds seti_time::ut1_utc_diff() const { // UT1 and UTC drift from each other, but are brought closer together when // leap seconds are added. They are never more than a second apart. if (ut1_utc_conv.size() == 0) { read_time_conversions(); } seti_time temp(*this); temp.base(UTC); // need to be sure we never extrapolate across a leap second. std::map<seti_time,seconds>::iterator i(ut1_utc_conv.upper_bound(temp)),j; j=i; j--; std::pair<seti_time,seconds> lower(*j), upper; if (i!=ut1_utc_conv.end()) { upper=*i; if (upper.second > (lower.second+seconds(0.95))) { upper.second-=seconds(1.0); // the upper point is on the wrong side of a leap // second. } } else { upper=lower; j--; lower=*j; if (upper.second > (lower.second+seconds(0.95))) { lower.second+=seconds(1.0); // the lower point is on the wrong side of a leap // second } } // now interpolate between the two points. seconds diff( (upper.second-lower.second)*((temp-lower.first)/(upper.first-lower.first)) ); return diff; }
// Assign value val to interval [keyBegin, keyEnd). // Overwrite previous values in this interval. // Do not change values outside this interval. // Conforming to the C++ Standard Library conventions, the interval // includes keyBegin, but excludes keyEnd. // If !( keyBegin < keyEnd ), this designates an empty interval, // and assign must do nothing. void assign( K const& keyBegin, K const& keyEnd, const V& val) { using iter_t = std::map<K, V>::const_iterator; if (!(keyBegin < keyEnd)) return; const iter_t lower_bound = map_.lower_bound(keyBegin); const iter_t upper_bound = map_.upper_bound(keyEnd); const iter_t prev = std::prev(lower_bound); const iter_t next = std::prev(upper_bound); // erase elements in range [lower_bound, upper_bound) map_.erase(lower_bound, upper_bound); if (!(prev->second == val)) { // set new value at the beginning of the range map_.insert(upper_bound, std::make_pair(keyBegin, val)); } if (!(next->second == val)) { // set next value at the end of the range map_.insert(upper_bound, std::make_pair(keyEnd, next->second)); } }
seconds seti_time::tai_utc_diff() const { // before 1972 TAI and UTC drifted freely. After 1972 the difference // is defined to be the cumulative number of leap seconds. if (tai_utc_conv.size() == 0) { read_time_conversions(); } seti_time temp(*this); temp.base(UTC); // find the time conversion prior to this time. std::map<seti_time,tai_conv>::iterator i(tai_utc_conv.upper_bound(temp)); i--; tai_conv conv(i->second); seconds diff(conv.a0+(temp.mjd().uval()-conv.d0)*conv.a1); return diff; }
void vstUndoRadialDistortion::ComputeOldXY(double xn, double yn, double& xo, double& yo) const { double rn = sqrt((xn*xn) + (yn*yn)); //// r is r squared map<double, double>::const_iterator next = lookup_.upper_bound(rn); map<double, double>::const_iterator prev = next; prev--; // The compiler will optimise this. double a = (*prev).first; double b = (*next).first; double c = rn; double d = (*prev).second; double e = (*next).second; double f = ((e-d)/(b-a))*(c-a) + d; xo = f*xn; yo = f*yn; }
heap_block_iterator find_containing_block ( const void *p ) { heap_block_iterator it ( m_heap_blocks.upper_bound ( ( void * ) p ) ); if ( it != m_heap_blocks.begin() ) { --it; if ( p < it->second.end() ) { assert ( p >= it->second.p ); // p is inside this heap block. return it; } } return m_heap_blocks.end(); }
/// Given a relocation from __compact_unwind, consisting of the RelocationRef /// and data being relocated, determine the best base Name and Addend to use for /// display purposes. /// /// 1. An Extern relocation will directly reference a symbol (and the data is /// then already an addend), so use that. /// 2. Otherwise the data is an offset in the object file's layout; try to find // a symbol before it in the same section, and use the offset from there. /// 3. Finally, if all that fails, fall back to an offset from the start of the /// referenced section. static void findUnwindRelocNameAddend(const MachOObjectFile *Obj, std::map<uint64_t, SymbolRef> &Symbols, const RelocationRef &Reloc, uint64_t Addr, StringRef &Name, uint64_t &Addend) { if (Reloc.getSymbol() != Obj->symbol_end()) { Reloc.getSymbol()->getName(Name); Addend = Addr; return; } auto RE = Obj->getRelocation(Reloc.getRawDataRefImpl()); SectionRef RelocSection = Obj->getRelocationSection(RE); uint64_t SectionAddr; RelocSection.getAddress(SectionAddr); auto Sym = Symbols.upper_bound(Addr); if (Sym == Symbols.begin()) { // The first symbol in the object is after this reference, the best we can // do is section-relative notation. RelocSection.getName(Name); Addend = Addr - SectionAddr; return; } // Go back one so that SymbolAddress <= Addr. --Sym; section_iterator SymSection = Obj->section_end(); Sym->second.getSection(SymSection); if (RelocSection == *SymSection) { // There's a valid symbol in the same section before this reference. Sym->second.getName(Name); Addend = Addr - Sym->first; return; } // There is a symbol before this reference, but it's in a different // section. Probably not helpful to mention it, so use the section name. RelocSection.getName(Name); Addend = Addr - SectionAddr; }
std::string toRoman(uint32_t number) { static std::map<uint32_t, std::string> alphabet = { {1000, "M" }, { 900, "CM" }, { 500, "D" }, { 400, "CD" }, { 100, "C" }, { 90, "XC" }, { 50, "L" }, { 40, "XL" }, { 10, "X" }, { 9, "IX" }, { 5, "V" }, { 4, "IV" }, { 1, "I" }, { 0, "" } }; std::string result; while (number > 0) { auto digit = *(--alphabet.upper_bound(number)); result += digit.second; number -= digit.first; } return result; }
V const& operator[](K const& key) const { return ( --m_map.upper_bound(key))->second; }
UTF16String *CreateValue(const wchar_t *pwszName){ xKey Key(pwszName, std::wcslen(pwszName)); const auto iterHint = xm_mapValues.upper_bound(Key); return &(xm_mapValues.emplace_hint(iterHint, std::move(Key), UTF16String())->second); }
Package *CreatePackage(const wchar_t *pwszName){ xKey Key(pwszName, std::wcslen(pwszName)); const auto iterHint = xm_mapPackages.upper_bound(Key); return &(xm_mapPackages.emplace_hint(iterHint, std::move(Key), Package())->second); }