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

FL::ParseResult AB::analyze(
        const TimeSeries &ts, Forest &forest, Patterns::Matcher &matcher, PatternsSet &patterns, MetricsSet &metrics)
{
    ParseResult result;

    try
    {
        if (ts.size() < 2)
            throw EAnalyze(E_INVALID_INPUT);

        Tree *tree = new Tree(ts);
        const int up   = IDGenerator::idOf("a");
        const int down = IDGenerator::idOf("b");

        for (int i = 0; i < ts.size()-1; i += 1)
        {
            const int &id =  (ts.value(i) <= ts.value(i+1))  ?  up  :  down;
            tree->add(new Node(NULL, id, i, i+1, 0));
        }
        forest.push_back(tree);
        result.treesAdded = 1;
        result.nodesAdded = (ts.size() + 1) / 2;
    }
    catch (const EAnalyze &e)
    {
        m_lastError = e;
    }
    return result;
}

 template <typename TimeSeries> typename TimeSeries::value_type empirical_average(TimeSeries const &t) {
   auto si = t.size();
   if (si == 0) return typename TimeSeries::value_type{};
   auto sum = t[0];
   for (int i = 1; i < si; ++i) sum += t[i];
   return sum / t.size();
 }

    template <typename TimeSeries> typename TimeSeries::value_type empirical_variance(TimeSeries const &t) {
      auto si = t.size();
      if (si == 0) return typename TimeSeries::value_type{};

      auto avg           = empirical_average(t);
      decltype(avg) sum2 = (t[0] - avg) * (t[0] - avg); // also valid if t[0] is an array e.g., i.e. no trivial contructor...
      for (int i = 1; i < si; ++i) sum2 += (t[i] - avg) * (t[i] - avg);
      return sum2 / t.size();
    }

 binned_series(TimeSeries const& t, int bin_size_)
    : bin_size(bin_size_), binned(t.size() / bin_size_, value_type{}) {
  if (bin_size_ > t.size())
   TRIQS_RUNTIME_ERROR << "bin size (" << bin_size_ << ") cannot be larger than size (" << t.size() << ") of time series";
  for (int i = 0; i < size(); i++) {
   for (int j = 0; j < bin_size; j++) binned[i] += t[i * bin_size + j];
   binned[i] /= bin_size;
  }
 }

Datum blocker(const RealMatrix& Ua, const RealMatrix sa, const vGroup& ensemble, const uint blocksize, uint repeats, ExtractPolicy& policy) {


  
  TimeSeries<double> coverlaps;

  for (uint i=0; i<repeats; ++i) {
    vector<uint> picks = pickFrames(ensemble.size(), blocksize);
    
    if (debug) {
      cerr << "***Block " << blocksize << ", replica " << i << ", picks " << picks.size() << endl;
      dumpPicks(picks);
    }
    
    vGroup subset = subgroup(ensemble, picks);
    boost::tuple<RealMatrix, RealMatrix> pca_result = pca(subset, policy);
    RealMatrix s = boost::get<0>(pca_result);
    RealMatrix U = boost::get<1>(pca_result);

    if (length_normalize)
      for (uint j=0; j<s.rows(); ++j)
        s[j] /= blocksize;

    coverlaps.push_back(covarianceOverlap(sa, Ua, s, U));
  }

  return( Datum(coverlaps.average(), coverlaps.variance(), coverlaps.size()) );

}

MOTIF_BEGIN

inline double EuclideanDistance(TimeSeries &t1, TimeSeries &t2, string name)
{
	double dist = 0.0;

	if(t1.size() != t2.size())
	{
		cout << t1.size() << "," << t2.size() << endl;
		cout << "Called by " << name << endl;
		system("pause");
	}

	for(size_t i = 0; i < t1.size(); ++i)
	{
		dist += pow(t1[i] - t2[i], 2.0);
	}

	return sqrt(dist);
}

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

BIGDECIMAL maxval::operator() (TimeSeries& timeSeries)
{
    int size = timeSeries.size();
    BIGDECIMAL currentMax = -10000000000000.0;
    for(int i = 0 ; i < size ; i++ )
    {
        if(timeSeries[i].val() > currentMax)
        {
            currentMax = timeSeries[i].val();
        }
    }

    return currentMax ;
}

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

bool FileCSV::save(const std::string &fileName, TimeSeries &ts)
{
    std::ofstream file(fileName.c_str());
    if (!file.is_open())
        return false;

    // Write header
    for (unsigned int i = 0; i < ts.header().size(); ++i)
    {
        file << ts.header()[i];
        if (i < ts.header().size() - 1)
            file << m_separator;
    }

    // Write data
    for (int row = 0; row < ts.size(); ++row)
    {
        file << std::endl << ts.time(row) << m_separator << ts.value(row);
    }
    file << std::endl;
    file.close();

    return true;
}

 int size() const { return ts.size(); }

double NSSKF::logp(const TimeSeries<DoubleData> & ts)const{
  initialize();
  double ans = 0;
  for(uint i=0; i<ts.size(); ++i) ans += update(ts[i]->value());
  return ans;
}