double energy( const container_type &q , const container_type &p , const mass_type &masses )
{
    const size_t n = q.size();
    double en = 0.0;
    for( size_t i=0 ; i<n ; ++i )
    {
        en += 0.5 * norm( p[i] ) / masses[i];
        for( size_t j=0 ; j<i ; ++j )
        {
            double diff = abs( q[i] - q[j] );
            en -= gravitational_constant * masses[j] * masses[i] / diff;
        }
    }
    return en;
}

pair< double , double > calc_mean_field( const container_type &x )
{
    size_t n = x.size();
    double cos_sum = 0.0 , sin_sum = 0.0;
    for( size_t i=0 ; i<n ; ++i )
    {
        cos_sum += cos( x[i] );
        sin_sum += sin( x[i] );
    }
    cos_sum /= double( n );
    sin_sum /= double( n );

    double K = sqrt( cos_sum * cos_sum + sin_sum * sin_sum );
    double Theta = atan2( sin_sum , cos_sum );

    return make_pair( K , Theta );
}

    void operator()( const container_type &q , container_type &dpdt ) const
    {
        const size_t n = q.size();
        for( size_t i=0 ; i<n ; ++i )
        {
            dpdt[i] = 0.0;
            for( size_t j=0 ; j<i ; ++j )
            {
                point_type diff = q[j] - q[i];
                double d = abs( diff );
                diff *= ( gravitational_constant * m_masses[i] * m_masses[j] / d / d / d );
                dpdt[i] += diff;
                dpdt[j] -= diff;

            }
        }
    }

		static std::size_t                           size(const container_type& p) { return p.size(); }

		static const_reverse_iterator                rend(const container_type& p) { return p.rend(); }

		static const_reverse_iterator                rbegin(const container_type& p) { return p.rbegin(); }

		static const_iterator                        end(const container_type& p) { return p.end(); }

		static void                                  emplace_back(container_type& cont, const PointExpr& p) { cont.emplace_back(p); }

 static void sort(container_type<size_t> &front, comparator_type comp) {
   std::sort(front.begin(), front.end(), comp);
 }

 static typename result_of::const_handle_type<container_type, iterator_handle_tag>::type handle( container_type const & container, value_type const & value )
 {
   for (typename container_type::const_iterator it = container.begin(); it != container.end(); ++it)
     if ( &(*it) == &value ) return it;
   return container.end();
 }

 void set_handle_invalid( container_type const & container, handle_type & handle, iterator_handle_tag )
 { handle = container.end(); }

 typename container_type::size_type size()
 {
    return m_queue.size(); 
 }

 BigUInt(const container_type& array) : 
     data(array.begin(), array.end()) 
 {
 }

		static bool                                  empty(const container_type& p) { return p.empty(); }

		static void                                  pop_back(container_type& pointSequence) { pointSequence.pop_back(); }

		static void                                  push_back(container_type& cont, const PointExpr& p) { cont.push_back(p); }

void deltaFml (const container_type& positions, container_type& forces)
{
    forces.clear ();
    forces.push_back (2*(positions.at (0)+20));
    forces.push_back (2*(positions.at (1)-43));
}

 void operator() (container_type & src_container, viennagrid::view<base_container_type, handle_container_tag> & dst_view)
 {
     for (typename container_type::iterator it = src_container.begin(); it != src_container.end(); ++it)
         if (pred_( *it ))
             dst_view.insert_handle( it.handle() );
 }

		static const_iterator                        begin(const container_type& p) { return p.begin(); }

			AsynchronousBufferReaderList(
				in_iterator_type ina,
				in_iterator_type ine,
				uint64_t rnumbuffers = 16,
				uint64_t rbufsize = 32,
				uint64_t offset = 0)
			:
				C(ina,ine), ita(C.begin()), ite(C.end()), numbuffers(rnumbuffers), bufsize(rbufsize)
			{
				while ( ita != ite && offset >= ::libmaus2::util::GetFileSize::getFileSize(*ita) )
				{
					offset -= ::libmaus2::util::GetFileSize::getFileSize(*ita);
					ita++;
				}

				if ( ita != ite )
				{
					reader_ptr_type treader(new AsynchronousBufferReader(*ita, numbuffers,bufsize,offset));
					reader = UNIQUE_PTR_MOVE(treader);
				}
			}