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

void TimeSeriesTest::testConstruction() {

    BOOST_MESSAGE("Testing time series construction...");

    TimeSeries<Real> ts;
    ts[Date(25, March, 2005)] = 1.2;
    ts[Date(29, March, 2005)] = 2.3;
    ts[Date(15, March, 2005)] = 0.3;

    TimeSeries<Real>::const_iterator cur = ts.begin();
    if (cur->first != Date(15, March, 2005)) {
        BOOST_ERROR("date does not match");
    }
    if (cur->second != 0.3) {
        BOOST_ERROR("value does not match");
    }

    ts[Date(15, March, 2005)] = 4.0;
    cur = ts.begin();
    if (cur->second != 4.0) {
        BOOST_ERROR("replaced value does not match" << cur->second << "\n");
    }

    ts[Date(15, March, 2005)] = 3.5;

    if (cur->second != 3.5) {
        BOOST_ERROR("set value operator not match" << cur->second << "\n");
    }
}

// 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;
}

 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;
 }

// 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;
}

 TimeSeries<Volatility>
 ConstantEstimator::calculate(const TimeSeries<Volatility>& volatilitySeries) {
     TimeSeries<Volatility> retval;
     const std::vector<Volatility> u = volatilitySeries.values();
     TimeSeries<Volatility>::const_iterator prev, next, cur, start;
     cur = volatilitySeries.begin();
     std::advance(cur, size_);
     // ICK.  This could probably be made a lot more efficient
     for (Size i=size_; i < volatilitySeries.size(); i++) {
         Size j;
         Real sumu2=0.0, sumu=0.0;
         for (j=i-size_; j <i; j++) {
             sumu += u[j];
             sumu2 += u[j]*u[j];
         }
         Real s = std::sqrt(sumu2/(Real)size_ - sumu*sumu / (Real) size_ /
                            (Real) (size_+1));
         retval[cur->first] = s;
         ++cur;
     }
     return retval;
 }