void IdCollection<ESXRecordT>::merge()
    {
        for (typename std::vector<Record<ESXRecordT> >::iterator iter (mRecords.begin()); iter!=mRecords.end(); ++iter)
            iter->merge();

        purge();
    }

    // adds a value, returning false if the given token is not
    // "reasonable".  A reasonable token is one not currently in use,
    // and if any previously used tokens are available, it must be one
    // of the previously used ones.  If no previously used tokens are
    // available, it must be the smallest unused token.  You'll get
    // good performance if you never choose a bad token and use the
    // most recently dropped token.
    bool add(token_type known_token, T const& value) {
        if (free_.empty()) {
            if (known_token == values_.size()) {
                values_.push_back(value);
#ifndef NDEBUG
                is_free_.push_back(false);
#endif
                return true;
            } else {
                return false;
            }
        } else {
            // If a replicand used add(), then it picked the token
            // from the bock of its free list.  So the replicant, the
            // presumed caller of this function, searches in reverse
            // order.
            typename std::vector<token_t>::reverse_iterator p = std::find(free_.rbegin(), free_.rend(), known_token);
            if (p == free_.rend()) {
                return false;
            }

            if (values_.size() > known_token) {
                free_.erase(p.base() - 1);
                values_[known_token] = value;
                rassert(is_free_[known_token]);
#ifndef NDEBUG
                is_free_[known_token] = false;
#endif

                return true;
            } else {
                return false;
            }
        }
    }

    void CorrectKiKf::correctKiKfEventHelper(std::vector<T>& wevector, double efixed,const std::string emodeStr)
{
  double Ei,Ef;
  float kioverkf;
  typename std::vector<T>::iterator it;
  for (it=wevector.begin(); it<wevector.end();)
  {
    if (emodeStr == "Direct")  //Ei=Efixed
    {
      Ei = efixed;
      Ef = Ei - it->tof();
    } else                     //Ef=Efixed
    { 
      Ef = efixed;
      Ei = Ef + it->tof();
    }
    // if Ei or Ef is negative, delete the event
    if ((Ei <= 0)||(Ef <= 0))
    {
      it=wevector.erase(it);
    } 
    else 
    {
      kioverkf = static_cast<float>(std::sqrt( Ei / Ef ));
      it->m_weight*=kioverkf;
      it->m_errorSquared*=kioverkf*kioverkf;
      ++it;
    }
  }
}

//
// BinaryTokenACS::output_ACS0
//
template<typename T> void BinaryTokenACS::output_ACS0
(std::ostream *out, std::vector<T> const &instructions)
{
   typename std::vector<T>::const_iterator instr;

   // 0
   *out << 'A' << 'C' << 'S' << '\0';
   write_ACS0_32(out, ObjectExpression::get_address_count());

   // 8
   for (instr = instructions.begin(); instr != instructions.end(); ++instr)
      instr->writeACS0(out);

   // directoryOffset
   ObjectData::Script::Iterate(write_ACS0_script_counter, NULL);
   write_ACS0_script_count(out);

   // directoryOffset+4
   ObjectData::Script::Iterate(write_ACS0_script, out);

   // directoryOffset+4+(scriptCount*12)
   ObjectData::String::Iterate(write_ACS0_string_counter, NULL);
   write_ACS0_string_count(out);

   // directoryOffset+4+(scriptCount*12)+4
   ObjectData::String::Iterate(write_ACS0_string_offset, out);

   // directoryOffset+4+(scriptCount*12)+4+(stringCount*4)
   ObjectData::String::Iterate(write_ACS0_string, out);
}

 //Prints graph node's adjacency lists
 void print() {
     for(typename std::vector<node>::iterator it = nodeL.begin(); it != nodeL.end(); it ++) {
         cout << "Node " << it->val << "'s adj list:\n";
         it->print();
         cout << endl;
     }
 }

 void cancelAll() {
   assert(*_closed);
   for (typename std::vector< Future<T> >::iterator it = this->_futures.begin();
        it != this->_futures.end();
        ++it)
     it->cancel();
 }

int GenomicRegionCollection<T>::TotalWidth() const { 
  int wid = 0; 
  for (typename std::vector<T>::const_iterator i = m_grv->begin(); i != m_grv->end(); ++i)
    //  for (auto& i : *m_grv) 
    wid += i->Width(); 
  return wid; 
}

void Array2D<T>::resize( const std::size_t& x, const std::size_t& y )
{

    // scale x-dimension up or down
    if( x != m_SizeX )
    {
        m_Array.resize( x );
        while( x > m_SizeX )
        {
            m_Array[m_SizeX].resize( m_SizeY, m_DefaultContent );
            ++m_SizeX;
        }
        m_SizeX = x;
    }

    // scale y-dimension up or down
    if( y != m_SizeY )
    {
        for( typename std::vector< std::vector<T> >::iterator it = m_Array.begin(); it != m_Array.end(); ++it )
        {
            it->resize( y, m_DefaultContent );
        }
        m_SizeY = y;
    }
}

void SaveNexusProcessed::appendEventListData(std::vector<T> events,
                                             size_t offset, double *tofs,
                                             float *weights,
                                             float *errorSquareds,
                                             int64_t *pulsetimes) {
  // Do nothing if there are no events.
  if (events.empty())
    return;

  typename std::vector<T>::const_iterator it;
  typename std::vector<T>::const_iterator it_end = events.end();
  size_t i = offset;

  // Fill the C-arrays with the fields from all the events, as requested.
  for (it = events.begin(); it != it_end; it++) {
    if (tofs)
      tofs[i] = it->tof();
    if (weights)
      weights[i] = static_cast<float>(it->weight());
    if (errorSquareds)
      errorSquareds[i] = static_cast<float>(it->errorSquared());
    if (pulsetimes)
      pulsetimes[i] = it->pulseTime().totalNanoseconds();
    i++;
  }
}

 void cancelAll() {
   QI_ASSERT(_closed.load());
   for (typename std::vector< Future<T> >::iterator it = this->_futures.begin();
        it != this->_futures.end();
        ++it)
     it->cancel();
 }

inline void  BaseGeneticAlgorithm<FITNESS_TYPE>::registerObserver(const std::shared_ptr<AlgorithmObserver<FITNESS_TYPE>> &observer)
{
    typedef std::set<typename AlgorithmObserver<FITNESS_TYPE>::ObserveableEvent> setType;
    const setType events = observer->getSubscribedEvents();
    for (const auto &it :events)
    {

        typename observers_map::iterator lb = _observers.lower_bound(it);

        if (lb != _observers.end() && !(_observers.key_comp()(it, lb->first)))
        {
            // key already exists
            // update lb->second if you care to
            lb->second.emplace_back(observer);
        }
        else
        {
            // the key does not exist in the map
            // add it to the map
            typename std::vector<std::shared_ptr<AlgorithmObserver<FITNESS_TYPE>>> list;
            list.emplace_back(observer);
            _observers.insert(lb, typename observers_map::value_type(it, list));    // Use lb as a hint to insert,
        }

    }

}

//**********************************************************************
PHX_EVALUATE_FIELDS(GlobalStatistics,workset)
{
    if (workset.num_cells == 0)
        return;

    Intrepid::FunctionSpaceTools::integrate<ScalarT>(volumes, ones,
            (this->wda(workset).int_rules[ir_index])->weighted_measure,
            Intrepid::COMP_BLAS);

    for (std::size_t cell = 0; cell < workset.num_cells; ++cell)
        total_volume += volumes(cell);

    typename std::vector<PHX::MDField<ScalarT,Cell,IP> >::size_type field_index = 0;
    for (typename std::vector<PHX::MDField<ScalarT,Cell,IP> >::iterator field = field_values.begin();
            field != field_values.end(); ++field,++field_index) {

        Intrepid::FunctionSpaceTools::integrate<ScalarT>(tmp, *field,
                (this->wda(workset).int_rules[ir_index])->weighted_measure,
                Intrepid::COMP_BLAS);

        for (std::size_t cell = 0; cell < workset.num_cells; ++cell) {
            averages[field_index] += tmp(cell);

            for (typename PHX::MDField<ScalarT,Cell,IP>::size_type ip = 0; ip < (field->dimension(1)); ++ip) {
                maxs[field_index] = std::max( (*field)(cell,ip), maxs[field_index]);
                mins[field_index] = std::min( (*field)(cell,ip), mins[field_index]);
            }
        }

    }
}

 std::vector<std::string> get_names() const
 {
   typename std::vector<std::string> lst;
   for(const_iterator i = begin(); i != end(); ++i)
   {
     lst.push_back(i->second);
   }
   return lst;
 }

inline boost::shared_ptr< Base > Construct(
	std::vector< t_OriginalVectorType >& vectors,
	std::vector< double >& labels,
	unsigned int const trainingSize,
	std::vector< std::string > const& kernelParameters,
	unsigned int const cacheSize = 0
)
{
	uint64_t sparseSize = 0;
	if ( t_Traits::SPARSE_ALLOWED ) {

		typename std::vector< SparseVector< t_Type > >::const_iterator ii    = vectors.begin();
		typename std::vector< SparseVector< t_Type > >::const_iterator iiEnd = vectors.end();
		for ( ; ii != iiEnd; ++ii )
			sparseSize += ii->Size();
	}

	uint64_t spanSize = 0;
	if ( t_Traits::SPAN_ALLOWED ) {

		typename std::vector< SparseVector< t_Type > >::const_iterator ii    = vectors.begin();
		typename std::vector< SparseVector< t_Type > >::const_iterator iiEnd = vectors.end();
		for ( ; ii != iiEnd; ++ii )
			spanSize += SpanVector< t_Type >( *ii ).Size();
	}

	uint64_t denseSize = 0;
	{	typename std::vector< SparseVector< t_Type > >::const_iterator ii    = vectors.begin();
		typename std::vector< SparseVector< t_Type > >::const_iterator iiEnd = vectors.end();
		for ( ; ii != iiEnd; ++ii )
			denseSize += DenseVector< t_Type >( *ii ).Size();
	}

	boost::shared_ptr< Base > result;

	if (
		t_Traits::SPARSE_ALLOWED &&
		( ( ! t_Traits::SPAN_ALLOWED ) || ( sparseSize <= spanSize ) ) &&
		( sparseSize <= denseSize )
	)
	{
		result = boost::shared_ptr< Base >( new t_KernelType< SparseVector< t_Type >, t_Traits >( vectors, labels, trainingSize, kernelParameters, cacheSize ) );
	}
	else if (
		t_Traits::SPAN_ALLOWED &&
		( spanSize <= denseSize )
	)
	{
		result = boost::shared_ptr< Base >( new t_KernelType< SpanVector< t_Type >, t_Traits >( vectors, labels, trainingSize, kernelParameters, cacheSize ) );
	}
	else {

		result = boost::shared_ptr< Base >( new t_KernelType< DenseVector< t_Type >, t_Traits >( vectors, labels, trainingSize, kernelParameters, cacheSize ) );
	}

	return result;
}

 property_t(const std::vector<std::vector<T> >& mtx) {
     vector matrix;
     for(typename std::vector<std::vector<T> >::const_iterator i = mtx.begin(); i != mtx.end(); ++i) {
         vector row;
         for(typename std::vector<T>::const_iterator j = i->begin(); j != i->end(); ++j)
             row.push_back(*j);
         matrix.push_back(row);
     }
     property_base::operator= <vector>(matrix);
 }

qi::FutureSync< qi::Future<T> > waitForFirst(std::vector< Future<T> >& vect) {
  typename std::vector< Future<T> >::iterator it;
  qi::Promise< qi::Future<T> > prom;
  qi::Atomic<int>* count = new qi::Atomic<int>();
  count->swap((int)vect.size());
  for (it = vect.begin(); it != vect.end(); ++it) {
    it->connect(boost::bind<void>(&detail::waitForFirstHelper<T>, prom, *it, count));
  }
  return prom.future();
}

 std::vector<T> getCallbacks() {
   typename std::vector<T> result;
   result.reserve(functionList.size() - invalidIndexCount);
   for (typename TypedFunctionPointerWrapperRefVector<T>::type::iterator it = functionList.begin(); it != functionList.end(); it++) {
     if (*it) {
       result.push_back((*it)->callback);
     }
   }
   return result;
 }

  void update() {
    typename std::vector<Element>::iterator i;
    int count = 0;
    SDL_Rect * warn_if_same_pos = grid.begin()->getSize();
    int warn_count = 0;
    for (i = grid.begin(); i != grid.end(); i++) {
#ifndef NO_WARNINGS
        if(i->getSize()->x == warn_if_same_pos->x
                &&
           i->getSize()->y == warn_if_same_pos->y)
        {
            warn_count++;
        }
        if(warn_count > 2)
        {
            printf("Warning!!!! you may be using the same object over and over again!\nuse object *  name = new * object(args); in your population routine: gridObject.append(*object); delete name; name = new * object(args);\n");
        }
#endif
#ifdef DEBUG
        printf("Render[%d]: at (%d,%d)\n",count,i->getSize()->x,i->getSize()->y);
#endif

      SDL_RenderCopy(i->getRenderer(), i->getImage(), NULL, i->getSize());
      warn_if_same_pos = i->getSize();
      count++;
    }
  }

 Y interpolate(const X&x) const {
     if (mElements.size() == 0) return Y();
 
     typename std::vector<element_type>::const_iterator it;
     it = std::lower_bound(mElements.begin(), mElements.end(), element_type(x));
     if (it != mElements.begin()) {
         it--;
     }   
     
     return it->eval(x);
 }

  virtual void execute(const DOM::Node<string_type, string_adaptor>& node, ExecutionContext<string_type, string_adaptor>& context) const
  {
    if(context.sink().start_element(name_, namespace_))
    {
      for(typename std::vector<InlineAttribute<string_type, string_adaptor> >::const_iterator a = attrs_.begin(), ae = attrs_.end(); a != ae; ++a)
        a->execute(node, context);

      ChainStackFrame<string_type, string_adaptor> frame(context);
      this->execute_children(node, context);
      context.sink().end_element(name_, namespace_);
    }
  } // execute