C++ Sequence::end方法代码示例

 void append_and_preserve_iter(Sequence &s, const Sequence &r,
                               Iterator &, std::forward_iterator_tag)
 {
     // Here we boldly assume that anything that is not random-access
     // preserves validity. This is valid for the STL sequences.
     s.insert(s.end(), r.begin(), r.end());
 }

int getLongestCommonPrefix(const Sequence &A, const Sequence &B)
{
	auto it = A.begin();
	auto jt = B.begin();
	while (it != A.end() && jt != B.end())
		if ((*it) != (*jt)) return it - A.begin();
		else it++, jt++;
	return it - A.begin();
}

void erase_unordered( Sequence& s, typename Sequence::iterator pos )
{
  assert( ! s.empty() && pos != s.end() );
  typename Sequence::iterator last = s.end();
  --last;
  if ( pos != last )
    *pos = *last; // *pos = std::move( *last );
  s.pop_back();
}

  void erase_if_dispatch(Sequence& c, Predicate p,
                         sequence_tag, IteratorStability)
  {
#if 0
    c.erase(std::remove_if(c.begin(), c.end(), p), c.end());
#else
    if (! c.empty())
      c.erase(std::remove_if(c.begin(), c.end(), p), c.end());
#endif
  }

vector<Operation> getModifiedOperationSequence(const Sequence &left_data_sequence, const Sequence &right_data_sequence)
{
	vector<Operation> result;
	assert(left_data_sequence.size() == right_data_sequence.size() + 1 || left_data_sequence.size() + 1 == right_data_sequence.size());
	auto ptr1 = left_data_sequence.begin(), ptr2 = right_data_sequence.begin();
	while (ptr1 != left_data_sequence.end() && ptr2 != right_data_sequence.end())
		if ((*ptr1) == (*ptr2)) result.push_back(Operation(*(ptr1), 0)), ptr1++, ptr2++;
		else if (left_data_sequence.size() == right_data_sequence.size() + 1) result.push_back(Operation(*(ptr1), -1)), ptr1++;
		else result.push_back(Operation(*(ptr2), 1)), ptr2++;
	if (ptr1 != left_data_sequence.end()) result.push_back(Operation(*(ptr1), -1));
	if (ptr2 != right_data_sequence.end()) result.push_back(Operation(*(ptr2), 1));
	return result;
}

void compute_stats(Sequence<double,Allocator>& value_list)
{
   //Format: min max sum mean median
   double min_value = 0.0;
   double max_value = 0.0;
   strtk::min_max_of_cont(value_list,min_value,max_value);
   std::cout << min_value << "\t" << max_value << "\t";

   double sum = std::accumulate(value_list.begin(),value_list.end(),0.0);
   std::cout << sum << "\t";
   std::cout << sum / value_list.size()  << "\t";

   std::nth_element(value_list.begin(),value_list.begin() + (value_list.size() / 2), value_list.end());
   std::cout << *(value_list.begin() + (value_list.size() / 2)) << "\t";
}

int main(void)
{
	Sequence seq = { 0 }; // legnth = 0 으로 초기화

	seq.push_back(5);
	seq.push_back(4);
	seq.push_back(3);
	seq.push_back(2);
	seq.push_back(1);

	seq.push_front(6);

	cout <<"size: " <<seq.size() <<endl;
	cout <<"contents: ";
	for ( int* p = seq.begin(); p != seq.end(); p = seq.next(p) ) {
		cout <<*p <<" ";
	}
	cout <<endl;


#ifdef _MSC_VER // 윈도우즈 명령창이 닫혀서 쓰는 꼼수
	printf("\n\nPress Enter key to exit ...");
	getchar();
#endif

	return 0;
}

void
sequence_iteration(
	Sequence &_sequence,
	UpdateAction const &_update_action
)
{
	for(
		auto it(
			_sequence.begin()
		);
		it != _sequence.end();
	)
	{
		switch(
			_update_action(
				*it
			)
		)
		{
		case fcppt::algorithm::update_action::remove:
			it =
				_sequence.erase(
					it
				);

			break;
		case fcppt::algorithm::update_action::keep:
			++it;

			break;
		}
	}
}

Range<typename Sequence::value_type> make_range(const Sequence & sequence)
{
    typedef typename Sequence::value_type T; // TODO: in C++11 second template parameter class T = Sequence::value_type
    const Iterator<T> & begin = IteratorAdapter<T, typename Sequence::const_iterator>(sequence.begin());
    const Iterator<T> & end = IteratorAdapter<T, typename Sequence::const_iterator>(sequence.end());
    return Range<T>(begin, end);
}

// la séquence initiale est lue et découpée en sous-séquences de
// longueur 20 ;
// chaque sous-séquence est terminée par une observation END pour que
// le HMM généré possède un état terminal
Sequences build_initial_sequences(const std::string& name)
{
    Sequence sequence = read_initial_sequence(name, false);
    Sequences sequences;
    unsigned int length = sequence.size() / 20;
    Sequence::const_iterator it = sequence.begin();
    unsigned int added = 0;
    unsigned int index = 0;

    sequences.push_back(Sequence());
    while (it != sequence.end()) {
        if (added == length) {
            sequences[index].push_back(Observation(0, END));
            ++index;
            added = 0;
            sequences.push_back(Sequence());
        }
        sequences[index].push_back(*it);
        ++added;
        ++it;
    }
    if (sequence.size() % 20 != 0) {
        sequences[index].push_back(Observation(0, END));
    }
    return sequences;
}

QKeySequence KeyLogger::keySequence(const Sequence & sequence)
{
    int sum = std::accumulate(sequence.begin(),
                              sequence.end(),
                              0, std::plus<int>());
    return QKeySequence(sum);
}

void Path::stitch(Sequence::iterator first_replaced,
                  Sequence::iterator last_replaced,
                  Sequence &source)
{
  if (!source.empty()) {
    if ( first_replaced != get_curves().begin() ) {
      if ( (*first_replaced)->initialPoint() != source.front()->initialPoint() ) {
        Curve *stitch = new StitchSegment((*first_replaced)->initialPoint(),
                                          source.front()->initialPoint());
        source.insert(source.begin(), boost::shared_ptr<Curve>(stitch));
      }
    }
    if ( last_replaced != (get_curves().end()-1) ) {
      if ( (*last_replaced)->finalPoint() != source.back()->finalPoint() ) {
        Curve *stitch = new StitchSegment(source.back()->finalPoint(),
                                          (*last_replaced)->finalPoint());
        source.insert(source.end(), boost::shared_ptr<Curve>(stitch));
      }
    }
  } else if ( first_replaced != last_replaced && first_replaced != get_curves().begin() && last_replaced != get_curves().end()-1) {
    if ( (*first_replaced)->initialPoint() != (*(last_replaced-1))->finalPoint() ) {
      Curve *stitch = new StitchSegment((*(last_replaced-1))->finalPoint(),
                                        (*first_replaced)->initialPoint());
      source.insert(source.begin(), boost::shared_ptr<Curve>(stitch));
    }
  }
}

vector<Operation> getOperationSequence(const Sequence &data_sequence, const int operation_type)
{
	vector<Operation> result;
	for (auto it = data_sequence.begin(); it != data_sequence.end(); it++)
		result.push_back(Operation((*it), operation_type));
	return result;
}

ExprReturnSP LitMatrixExprReturn::multiply( LitMatrixExprReturn &litMatrixExprReturn ) {

	__int64 rows1, columns1;
	getRowsAndColumns( rows1, columns1 );

	__int64 rows2, columns2;
	litMatrixExprReturn.getRowsAndColumns( rows2, columns2 );

	if ( rows1 == 1 && columns1 == 1 ) {
		double multiplier = getSequence()[0];
		Sequence sequence = litMatrixExprReturn.getSequence();
		for( Sequence::iterator sqnItr = sequence.begin() ; sqnItr != sequence.end() ; (void)++sqnItr ) {
			*sqnItr *= multiplier;
		}
		return create( getBlock(), litMatrixExprReturn.getDT(), sequence );
	}

	if ( rows2 == 1 && columns2 == 1 ) {
		double multiplier = litMatrixExprReturn.getSequence()[0];
		Sequence sequence = getSequence();
		for( Sequence::iterator sqnItr = sequence.begin() ; sqnItr != sequence.end() ; (void)++sqnItr ) {
			*sqnItr *= multiplier;
		}
		return create( getBlock(), getDT(), sequence );
	}

	if ( columns1 != rows2 ) {
		if (  ( rows1 == 1 || columns1 == 1 ) && rows1 == rows2  ) std::swap( rows1, columns1 );
		else if (  ( rows2 == 1 || columns2 == 1 ) && columns1 == columns2  ) std::swap( rows2, columns2 ); 
		else { /* THROW ERROR */ }
	}

	Sequence sequence;
	Sequence &rhsSequence = litMatrixExprReturn.getSequence();
	for( long long ix = 0 ; ix < rows1 ; (void)++ix ) {
		for( long long jx = 0 ; jx < columns2 ; (void)++jx ) {
			double sum = 0;
			for( long long kx = 0 ; kx < columns1 ; (void)++kx ) {
				sum += getSequence()[ ix*rows1 + kx ] * rhsSequence[ kx*rows2 + jx ];
			}
			sequence.push_back( sum );
		}
	}

	SFC::DT dominantDT = SFCTypesManager::getDominantType( getDT(), litMatrixExprReturn.getDT() );
	return create( getBlock(), (int) rows1, (int) columns2, dominantDT, sequence );
}

void mark(
    MultiArray& m,const Sequence& pts,
    const point& p,int dx,int dy)
{
    for(int k=p.x<0||p.y<0||p.x>=m.shape()[0]||p.y>=m.shape()[1]?1:0,
            k_end=distZ2inf(p,pts.begin(),pts.end()); k<k_end; ++k) {
        int x=p.x-k*dx;
        int y=p.y-k*dy;
        if(x>=0&&y>=0&&x<m.shape()[0]&&y<m.shape()[1])m[x][y]=true;
    }
}