void UpdaterBoostNoUnits::solar_system_coor::operator()(const container_t& p, container_t& dqdt) const
{
    assert(p.size() == m_masses.size());
    assert(dqdt.size() == m_masses.size());
    const auto n = m_masses.size();
    for(size_t i=0 ; i<n ; ++i)
        dqdt[i] = p[i] / m_masses[i];
}

void write(const std::string& name, const container_t& cont)
{
	std::cout << name << ": ";

	for( container_t::const_iterator it = cont.begin(); it != cont.end(); ++it )
		std::cout << *it << " ";

	std::cout << "\n";
}

  inline void
  pointmesh2d<point_t>::add_row(container_t const& c)
  {
    std::size_t oldsize(_points.size());

    std::copy(c.begin(), c.end(), std::back_inserter(_points));

    _width = _points.size() - oldsize;
    ++_height;
  }

void set_add(container_t& container, typename container_t::value_type value)
{
    auto it = container.begin();
    while (it != container.end() && *it < value)
    {
        ++it;
    }

    if (*it != value)
    {
        container.insert(it, value);
    }
}

  typename std::enable_if<std::is_class<container_t>::value && sizeof(typename container_t::value_type)!=0
			  //has_member_function size,
			  ,
			  const typename container_t::value_type*>::type
  end(const container_t& _array){

    return &_array[_array.size()];
    
  }

  bool compare(container_t const & lhs, container_t const & rhs, typename container_t::value_type precision)
  {
    if (&lhs == &rhs) {
      return true;
    }
    if (lhs.size() != rhs.size()) {
      return false;
    }
    typename container_t::const_iterator il(lhs.begin());
    typename container_t::const_iterator ir(rhs.begin());
    typename container_t::const_iterator il_end(lhs.end());
    for (/**/; il != il_end; ++il, ++ir) {
      if (fabs(*il - *ir) > precision) {
	return false;
      }
    }
    return true;
  }

 value_t convert2(const container_t& c) {
     try {
         return c.operator value_t();
     }
     catch(const std::exception& e) {
         OH_FAIL("Unable to convert type '" << c.type().name()
             << "' to type '" << typeid(value_t).name() << "' - " << e.what());
     }
 }

static void makeWeightedOne(float wA,
							std::vector<VisibilityVector::node_benefits_pair_t>::const_iterator & a,
							std::vector<VisibilityVector::node_benefits_pair_t>::const_iterator & aEnd,
							container_t & result) {
	// Add the elements of the single map.
	while(a != aEnd) {
		const VisibilityVector::benefits_t weightedBenefits = (wA * a->second);
		if(weightedBenefits > 0) {
			result.emplace_back(a->first, weightedBenefits);
		}
		++a;
	}
}

static void makeWeightedTwo(float wA,
							std::vector<VisibilityVector::node_benefits_pair_t>::const_iterator & a,
							std::vector<VisibilityVector::node_benefits_pair_t>::const_iterator & aEnd,
							float wB,
							std::vector<VisibilityVector::node_benefits_pair_t>::const_iterator & b,
							std::vector<VisibilityVector::node_benefits_pair_t>::const_iterator & bEnd,
							container_t & result) {
	// Compare elements of the two maps.
	while(a != aEnd && b != bEnd) {
		if(a->first < b->first) {           // Object is only in map of vvA.
			const VisibilityVector::benefits_t weightedBenefits = (wA * a->second);
			if(weightedBenefits > 0) {
				result.emplace_back(a->first, weightedBenefits);
			}
			++a;
		} else if(b->first < a->first) {    // Object is only in map of vvB.
			const VisibilityVector::benefits_t weightedBenefits = (wB * b->second);
			if(weightedBenefits > 0) {
				result.emplace_back(b->first, weightedBenefits);
			}
			++b;
		} else {                            // Object is in both maps.
			const VisibilityVector::benefits_t weightedBenefits = (wA * a->second + wB * b->second);
			if(weightedBenefits > 0) {
				result.emplace_back(a->first, weightedBenefits);
			}
			++a;
			++b;
		}
	}
	if(a == aEnd) {
		makeWeightedOne(wB, b, bEnd, result);
	} else {
		makeWeightedOne(wA, a, aEnd, result);
	}
}

 void zero(container_t & vv)
 {
   std::fill(vv.begin(), vv.end(), 0);
 }

 bool socket_t::send(const container_t& message, int flags) {
   return send(static_cast<const void*>(message.data()), message.size(), flags);
 }

 void insert(const KEY &key, const VALUE &value)
 {
     erase(key);
     const pair_t p(key, value);
     auto it = std::lower_bound(m_contents.begin(), m_contents.end(), p);
     m_contents.insert(it, p);
 }

 const_iterator findKey(const KEY& key) const
 {
     // binary search for key
     const_iterator it(std::lower_bound(m_contents.begin(), m_contents.end(), key, KeyCmp()));
     if (it != m_contents.end() && CMP()(key, it->first)) // it > it-1, check ==
         it = m_contents.end();
     return it;
 }

 const_iterator findValue(const VALUE& value) const
 {
     for (auto&& it = m_contents.begin(); it != m_contents.end(); ++it)
     {
         if (it->second == value)
             return it;
     }
     return m_contents.end();
 }

    void erase(const KEY& key)
    {
        const_iterator it = findKey(key);
        if (it != m_contents.end())
        {
            // Avoid std::vector.erase here due to bug in libstdc++ < v4.9
#if PONDER_WORKAROUND_GCC_N2350
            std::size_t pos = it - m_contents.begin();
            const std::size_t sz = m_contents.size() - 1;
            while (pos < sz)
                m_contents[pos] = m_contents[pos + 1], ++pos;
            m_contents.resize(sz);
#else
            m_contents.erase(it);
#endif
        }
    }

 bool tryFind(const KEY& key, const_iterator& returnValue) const
 {
     const_iterator it = findKey(key);
     if (it != m_contents.end())
     {
         returnValue = it;
         return true;
     }
     return false; // not found
 }

	void reserve(size_t size) { __container.reserve(size); }

 bool containsValue(const VALUE& value) const
 {
     return findValue(value) != m_contents.end();
 }

 const_iterator end() const      { return m_contents.end(); }

	void erase(const_iterator_t position)
	{
		__container.erase(__position_to_iterator(position));
	}