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

// Compute HammingDistance between two time series
size_t NTuple::HammingDistance( TimeSeries& t1, TimeSeries& t2 )
{
	size_t h = 0;
	TimeSeriesIter iter1 = t1.begin();
	TimeSeriesIter iter2 = t2.begin();
	while( iter1 != t1.end() && iter2 != t2.end() )
	{
		// Accumulate the Hamming distance for each NTuple
		h += *iter1++ - *iter2++;
	}
	return h;
}

// Iterate only the k'th variable with respect to the given reference time series
size_t DynSysModel::Iterate( TimeSeries& ref_series, size_t k, TimeSeries& result, size_t kov )
{
	// Make sure the result is empty
	result.clear();

	// Hamming distance for bit k
	size_t h = 0;

	TimeSeriesIter t_iter = ref_series.begin();

	// Empty series in => empty series out
	if( t_iter == ref_series.end() ) return h;

	// Save the initial state as the first state in the result
	mState = *t_iter;

	// Force the knockout variable to zero - no longer needed, corrected when file is read in
	// if( kov != 0 ) mState.Reset(kov);
	result.push_back( mState );

	bool f;
	while( true )
	{
		// Merge the next state from the time series with the function evaluation
		// (a) increment iterator and check for end of time series
		++t_iter;
		if( t_iter == ref_series.end() ) break;

		// Evaluate the k'th polynomial at the current state
		//   to produce a new value for the k'th variable for time i+1
		f = mModel[k-1].Evaluate( mState );

		// (b) assign value pointed to by iterator to mState (t[i+1])
		mState = *t_iter;

		// Force the knockout variable to zero - no longer needed, corrected when file is read in
		// if( kov != 0 ) mState.Reset(kov);

		// Accumulate Hamming Distance =  t'[i+1][k] - t[i+1][k]
		h += (mState[k] ^ f) ? 1 : 0;

		// (c) create t'[i+1] = t[i+1] with k'th element replaced by f(t'[i])
		mState.Assign( k, f );

		// Save t'[i+1]
		result.push_back( mState );
	}
	return h;
}

 std::vector<Real> IntervalPrice::extractValues(
                                        const TimeSeries<IntervalPrice>& ts,
                                        IntervalPrice::Type t)  {
     std::vector<Real> returnval;
     returnval.reserve(ts.size());
     for (TimeSeries<IntervalPrice>::const_iterator i = ts.begin();
          i != ts.end(); ++i) {
         returnval.push_back(i->second.value(t));
     }
     return returnval;
 }