Esempio n. 1
0
Directory::Entry::Type ScanningWatch::type(const Stat& stbuf) {
#ifdef _WIN32
  if (stbuf.ISDEV()) {
    return Directory::Entry::TYPE_DEV;
  } else if (stbuf.ISDIR()) {
    return Directory::Entry::TYPE_DIR;
  } else if (stbuf.ISREG()) {
    return Directory::Entry::TYPE_REG;
  }
#else
  if (stbuf.ISBLK()) {
    return Directory::Entry::TYPE_BLK;
  } else if (stbuf.ISCHR()) {
    return Directory::Entry::TYPE_CHR;
  } else if (stbuf.ISDIR()) {
    return Directory::Entry::TYPE_DIR;
  } else if (stbuf.ISFIFO()) {
    return Directory::Entry::TYPE_FIFO;
  } else if (stbuf.ISLNK()) {
    return Directory::Entry::TYPE_LNK;
  } else if (stbuf.ISREG()) {
    return Directory::Entry::TYPE_REG;
  } else if (stbuf.ISSOCK()) {
    return Directory::Entry::TYPE_SOCK;
  }
#endif
  else {
    debug_break();
    return Directory::Entry::TYPE_REG;
  }
}
Esempio n. 2
0
void AMerge::clear_src() {
	cout << "Remove source files ..." << flush;
	foreach( fs::path dir, _directories ) {
		Stat status;
		status.scan_directory( dir, SCAN_MODE_RECURSIVE | SCAN_MODE_FILES | SCAN_MODE_DIRS );
		status.remove();
	}
Esempio n. 3
0
bool ScanningWatch::equals(const Stat& left, const Stat& right) {
  return type(left) == type(right)
         &&
         left.get_mtime() == right.get_mtime()
         &&
         left.get_size() == right.get_size();
}
Esempio n. 4
0
    void Actors::calculateCreatureStatModifiers (const MWWorld::Ptr& ptr)
    {
        CreatureStats &creatureStats = MWWorld::Class::get(ptr).getCreatureStats(ptr);
        const MagicEffects &effects = creatureStats.getMagicEffects();

        // attributes
        for(int i = 0;i < ESM::Attribute::Length;++i)
        {
            Stat<int> stat = creatureStats.getAttribute(i);
            stat.setModifier(effects.get(EffectKey(ESM::MagicEffect::FortifyAttribute, i)).mMagnitude -
                             effects.get(EffectKey(ESM::MagicEffect::DrainAttribute, i)).mMagnitude);

            creatureStats.setAttribute(i, stat);
        }

        // dynamic stats
        for(int i = 0;i < 3;++i)
        {
            DynamicStat<float> stat = creatureStats.getDynamic(i);
            stat.setModifier(effects.get(EffectKey(80+i)).mMagnitude -
                             effects.get(EffectKey(18+i)).mMagnitude);

            creatureStats.setDynamic(i, stat);
        }
    }
Esempio n. 5
0
void CSStats::readFromXML( const std::string& entityID, const pugi::xml_node& node ) {
    CStats component;

    for( pugi::xml_node statNode : node ) {
        Stat stat;

        pugi::xml_attribute idAtt = statNode.attribute( "id" );
        if( !idAtt ) {
            DOS_ERROR( true, "Unable to load entity Stat. ID is missing" );
            continue;
        }

        stat.setID( idAtt.as_int() );

        pugi::xml_attribute valueAtt = statNode.attribute( "value" );
        if( !valueAtt ) {
            DOS_ERROR( true, "Unable to load entity Stat. Value is missing" );
            continue;
        }

        stat.setBase( valueAtt.as_float() );

        component.stats.push_back( stat );
    }

    COMPONENT_MANAGER.addProperty( component, entityID );
}
Esempio n. 6
0
void PIOS::print_stats(run_arg *args)
{
	char regionstr[32], chunkstr[32], mbstr[32];
	cfs_duration_t highest, lowest, average;
	__u64 agvsize;
	Stat *st = args->st;

	assert(st != NULL);
	st->Record("%d\t%s\t%llu\t%d\t%llu\t%s\t%s\t",
		args->runno,
		args->verify ? "Read" : "Write",
		args->startime,
		args->threadcount,
		args->regioncount,
		in_MBs(regionstr, args->regionsize),
		in_MBs(chunkstr, args->chunksize));

	/* TODO: chunk noise */
	assert(args->chunknoise == 0);
	agvsize = args->regionsize * args->regioncount;

	find_high_low_duration(args, &highest, &lowest, &average);
	in_MBs(mbstr, agvsize *  params.TimeUnit / args->iotime);

	st->Record("%s/s\t\t%2.3fs\t%2.3fs\t%2.3fs\n",
		mbstr,
		((double)(lowest / 1000000)) / 1000.0,
		((double)(highest / 1000000)) / 1000.0,
		((double)(args->iotime / 1000000)) / 1000.0);
}
Esempio n. 7
0
int test3() {
	srand(time(NULL));
	std::cout << "QUICKSORT" << std::endl;
	Float<&sort> tab2[20];
	int i,taille = 500;
	std::cout << "creation du tableau" << std::endl;
	for(i=0;i<taille;i++) {
		tab2[i] = 1 + (int)(((double)rand())/((double)RAND_MAX+1)*(double)1000);
	}
	sort.time_reset();
	std::cout << "triage du tableau" << std::endl;
	quicksort<&sort>(tab2,0,taille);	
	std::cout << "[";
	for (int i=0; i<taille; i++) {
		std::cout << tab2[i];
		if (i < taille - 1)
			std::cout << ", ";
		if (i%20==1)
			std::cout << std::endl;
	}
	std::cout << "]" << std::endl;
	sort.show_stats();

	return 0;

}
Esempio n. 8
0
bool connectionValid(int mask, Stat S){
    for (int i = 0; i < 5; i++) if (maskGet(mask, i)){
        Stat::iterator it = SSfind(S, i);
        if (it != S.end()) S.erase(it);
    }
    return S.empty();
}
Esempio n. 9
0
 void Print_Me(){
   printf("Score_Stats: ");
   Score.Print_Me();
   printf("\n");
   printf("Length_Stats: ");
   FinalGen.Print_Me();
   printf("\n");
 }
Esempio n. 10
0
static void connect_server(int thread_id, int repead_id, string host, int port)
{
    char peerid[21], ip[16];
    snprintf(peerid, 20, "%10d%10d", thread_id, repead_id);
    peerid[20] = '\0';
    snprintf(ip, 15, "%d.%d.%d.%d", thread_id & 0x000000ff, repead_id & 0x000000ff, port & 0x000000ff, host[0] & 0x000000ff);
    ip[15] = '\0';
    Peer peer;
    peer.__set_ip(ip);
    peer.__set_idc("tc");
    peer.__set_port(host[1] & 0x000000ff);
    peer.__set_peerid(peerid);
    Stat stat;
    stat.__set_downloaded(thread_id * repead_id);
    stat.__set_left(thread_id + repead_id);
    stat.__set_uploaded(thread_id);
    stat.__set_status(static_cast<Status::type>(thread_id * repead_id % 5));
    AnnounceRequest request;
    request.__set_infohash("abcdefghijklmnopqrst");
    request.__set_is_seed(thread_id * repead_id % 2);
    request.__set_num_want(50);
    request.__set_peer(peer);
    request.__set_stat(stat);
    //printf("%s:%d peerid: %s, infohash: %s, is_seed: %d, status: %d\n", ip, peer.port, peer.peerid.c_str(), request.infohash.c_str(), request.is_seed, stat.status);
    AnnounceResponse response;

    shared_ptr<TSocket> socket(new TSocket(host.c_str(), port));
    socket->setConnTimeout(3000);
    socket->setSendTimeout(3000);
    socket->setRecvTimeout(5000);
    shared_ptr<TTransport> transport(new TFramedTransport(socket));
    shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(transport));
    AnnounceClient client(protocol);

    try {
        transport->open();
        client.announce(response, request);
        transport->close();
        //printf("success\n");
     } catch (TException &tx) {
       printf("ERROR: %s\n", tx.what());
       return;
     }

#if 0
    printf("/*************************************************************/\n");
    printf("%s:%d peerid: %s, infohash: %s, is_seed: %d, status: %d\n", ip, peer.port, peerid, request.infohash.c_str(), request.is_seed, stat.status);
    printf("ret: %d, failure_reason: %s, min_interval: %d, have_seed: %d, peers_num: %ld\n"
            , response.ret, response.failure_reason.c_str(), response.min_interval, response.have_seed, response.peers.size());
    for (std::vector<Peer>::iterator it = response.peers.begin(); it != response.peers.end(); ++it) {
        printf("%s:%d\n", it->ip.c_str(), it->port);
    }
    printf("/*************************************************************\n");
#endif
}
Esempio n. 11
0
void CSStats::applyHPRegen( CStats& component ) {
    Stat* health = component.getStat( Stat::SID_Health );

    if( health ) {
        Stat* hpRegen = component.getStat( Stat::SID_HPRegen );

        if( hpRegen ) {
            health->change( hpRegen->max );
        }
    }
}
Esempio n. 12
0
void SScombine(Stat &S, int i, int j){
    Stat::iterator iti = SSfind(S, i);
    Stat::iterator itj = SSfind(S, j);
    if (iti == itj) return;
    set<int> s(*iti);
    for (set<int>::iterator it = itj->begin(); it != itj->end(); it++){
        s.insert(*it);
    }
    S.erase(iti);
    S.erase(itj);
    S.insert(s);
}
Esempio n. 13
0
int test1() {
	//st.time_reset();
	naive.time_reset();
	std::cout << "SOMME NAIVE" << std::endl;
	sommeNaive<&naive>(1,32000);
	naive.show_stats();
	std::cout << std::endl;

	//gauss.time_reset();
	std::cout << "SOMME DE GAUSS" << std::endl;
	sommeGauss<&gauss>(1,320);
	gauss.show_stats();
	std::cout << std::endl;

	//std::cout << "TRI BULLES" << std::endl;

	std::cout << "TRI SELECTION" << std::endl;
	int taille = 10;
	Float<&s> tab1[10] = {12.1,48.3,5.4,9,1.7,20.5,1.3,24.5,3,7};
	// triBulles<&s>(tab,taille);

	// s.time_reset();
	triSelection<&s>(tab1,taille);
	std::cout << "[";
	for (int i=0; i<taille; i++) {
		std::cout << tab1[i];
		if (i < taille-1)
			std::cout << ", ";
	}
	std::cout << "]" << std::endl;
	s.show_stats();

	// sort.time_reset();
	std::cout << "QUICKSORT" << std::endl;
	Float<&sort> tab2[20];
	int i;
	for(i=0;i<20;i++) {
		tab2[i]=20-i;
	}

	quicksort<&sort>(tab2,0,19);	
	std::cout << "[";
	for (int i=0; i<20; i++) {
		std::cout << tab2[i];
		if (i < 19)
			std::cout << ", ";
	}
	std::cout << "]" << std::endl;
	sort.show_stats();

	return 0;
}
Esempio n. 14
0
void StatisticsBase::safeFlushInformation(int fd) const {
#ifdef CVC4_STATISTICS_ON
  for (StatSet::iterator i = d_stats.begin(); i != d_stats.end(); ++i) {
    Stat* s = *i;
    if (d_prefix.size() != 0) {
      safe_print(fd, d_prefix);
      safe_print(fd, s_regDelim);
    }
    s->safeFlushStat(fd);
    safe_print(fd, "\n");
  }
#endif /* CVC4_STATISTICS_ON */
}
Esempio n. 15
0
string strFromStat(Stat S){
    string s;
    for (Stat::iterator it = S.begin(); it != S.end(); it++){
        string tmp = "{";
        for (set<int>::iterator i = it->begin(); i != it->end(); i++){
            tmp += strFromInt(*i) + ", ";
        }
        tmp[tmp.size() - 2] = '}';
        tmp[tmp.size() - 1] = ' ';
        s += tmp;
    }
    return s;
}
Esempio n. 16
0
Stat getStat0(int m){
    Stat S;
    set<int> cur;
    for (int i = 0; i < 5; i++) if (maskGet(m, i)) {
        if (i != 0 && !maskGet(m, i - 1) ){
            if (!cur.empty()) S.insert(cur);
            cur.clear();
        }
        cur.insert(i);
    }
    if (!cur.empty()) S.insert(cur);
    return S;
}
/* 测量项目other在min和max之间的人找出来,统计他们的item的值 */
void Query::query_data_by_others(Stat &stat, QString item, QString other, float min, float max)
{
	stat.reset();

	for (int i = 0; i < npeople; i++) {
		float other_data = get_data_by_item(&people[i], other);
		if (other_data <= max && other_data >= min) {
			float data = get_data_by_item(&people[i], item);
			if (data != -1) {
				stat.add_element(data);
			}
		}
	}
}
Esempio n. 18
0
void StatisticsBase::flushInformation(std::ostream &out) const {
#ifdef CVC4_STATISTICS_ON
  for(StatSet::iterator i = d_stats.begin();
      i != d_stats.end();
      ++i) {
    Stat* s = *i;
    if(d_prefix != "") {
      out << d_prefix << s_regDelim;
    }
    s->flushStat(out);
    out << std::endl;
  }
#endif /* CVC4_STATISTICS_ON */
}
Esempio n. 19
0
            /// Set modified value an adjust base accordingly.
            void setModified (T value, const T& min, const T& max = std::numeric_limits<T>::max())
            {
                mStatic.setModified (value, min, max);

                if (mCurrent>getModified())
                    mCurrent = getModified();
            }
Esempio n. 20
0
            /// Set base and adjust modified accordingly.
            void setBase (const T& value)
            {
                mStatic.setBase (value);

                if (mCurrent>getModified())
                    mCurrent = getModified();
            }
void Query::query_data(Stat &stat, QString item, QString nativeplace, 
					   QString district, QString armtype, QString education, QString militaryrank)
{
	int pm;
	QList<int> parameters;

	stat.reset();
	if (item == "") return;

	parameters << get_value_by_key(nativeplace_map, nativeplace);
	parameters << get_value_by_key(district_map, district);
	parameters << get_value_by_key(armtype_map, armtype);
	parameters << get_value_by_key(education_map, education);
	parameters << get_value_by_key(militaryrank_map, militaryrank);

	pm = 0;
	while (pm < PARAMETER_SIZE && parameters[pm] == -1) {
		pm++;
	}
	if (pm == PARAMETER_SIZE) {
		for (int i = 0; i < this->npeople; i++) {
			People *p = &people[i];
			float item_data = get_data_by_item(p, item);
			if (item_data > 0) {
				stat.add_element(item_data);
			}
		}
	} else {
		List *l = find_list(parameters[pm], pm);
		People *p = l->first;

		while (p) {
			bool all_parameter_match = true;
			for (int ii = pm + 1; ii < PARAMETER_SIZE; ii++) {
				if (parameters[ii] != -1 && !match_parameter(p, ii, parameters[ii])) {
					all_parameter_match = false;
					break;
				}
			}
			float item_data = get_data_by_item(p, item);
			if (all_parameter_match && item_data > 0) {
				stat.add_element(item_data);
			}
			p = p->next[pm];
		}
	}
}
bool ResultsGenerator::NextResult(Result& out)
{
	// check if there are still remaining parts
	auto pRemain = m_remains.begin();
	for (; pRemain != m_remains.end(); pRemain++)
		if (*pRemain > 0)
			break;
	if (pRemain == m_remains.end())
		return false;  // no more parts

	Result bestResult;
	Amounts bestRashod(m_remains.size());
	bool first = true;
	m_layout2d.ResetCompletedCounter();
	for (auto pSheet = m_sheets.begin(); pSheet != m_sheets.end(); pSheet++)
	{
		Stat stat;
		stat.MakeZero();
		OldLayoutResult raskroy;
		Amounts rashod(m_remains.size());
		if (!m_layout2d.Optimize(pSheet->rect, stat, 0, raskroy, rashod))
			continue;
		if (bestResult.Statistics < stat || first) {
			bestResult.amount = m_remains / rashod;
			if (ControlRemains && bestResult.amount > pSheet->Amount)
				continue;  // not enough sheets

			bestResult.Statistics = stat;
			bestResult.raskroy = raskroy;
			bestResult.sheet = pSheet;
			bestRashod = rashod;
			first = false;
		}
	}
	if (first)
		throw CannotSetPartsException(&m_sheets, m_sizes, &m_remains);

	m_remains -= bestRashod * bestResult.amount;
	RemoveExostedSizes();
	if (ControlRemains)
		bestResult.sheet->Amount -= bestResult.amount;
#ifdef _DEBUG
	CheckResult(bestResult);
#endif
	out = bestResult;
	return true;
}
Esempio n. 23
0
void main( void )                       
{                                       
   const int NUM = 9;                   
   int       array[NUM];                
   time_t    t;                         
   srand((unsigned) time(&t));          
   cout << "Vector: ";                  
   for (int i=0; i < NUM; i++) {        
      array[i] = rand() % 9 + 1;
      cout << array[i] << ' '; }        
   cout << endl;                        
                                         
   Stat  obj;                            
   obj.readVector( array, NUM );         
   cout << "min is " << obj.getMin()     
      << ", max is " << obj.getMax()     
      << ", median is " << obj.getMed()  
      << endl;                           
}                                        
Esempio n. 24
0
 virtual bool read(ConnectionReader& connection) {
     double now = Time::now();
     Bottle b;
     bool ok = b.read(connection);
     if (ok) {
         mutex.wait();
         ct++;
         if (ct>1) {
             double dt = now - lastTime;
             period.add(dt);
         }
         lastTime = now;
         printf("Period is %g +/- %g (%d)\n",
                period.mean(),
                period.deviation(),
                ct);
         mutex.post();
     }
     return ok;
 }
Esempio n. 25
0
Stat newStat(Stat S, int mask){
    set<set<int> > T;
    for (int i = 0; i < 5; i++) if (maskGet(mask, i)){
        SSinsertNew(T, i);
        if (i != 0 && maskGet(mask, i - 1)) SScombine(T, i, i - 1);
        for (int j = 0; j < i; j++) if (maskGet(mask, j)){
            if (SSfind(S, i) == S.end()) continue;
            if (SSfind(S, i) == SSfind(S, j))  SScombine(T, i, j);            
        }        
    }    
    return T;
}
Esempio n. 26
0
void cleanup() {
	Stat stat;
	stat.scan_directory( fs::path(".test"), SCAN_MODE_RECURSIVE | SCAN_MODE_FILES | SCAN_MODE_DIRS );
	stat.sort();
	std::reverse( stat.begin(), stat.end() );
	stat.remove();
	fs::remove( fs::path(".test") );
}
Esempio n. 27
0
ProcStats::ProcStats(AggregateStat* parentStat, AggregateStat* _coreStats) : coreStats(_coreStats) {
    uint32_t maxProcs = zinfo->lineSize;
    lastUpdatePhase = 0;

    // Check that coreStats are appropriate
    assert(coreStats);
    for (uint32_t i = 0; i < coreStats->size(); i++) {
        Stat* s = coreStats->get(i);
        AggregateStat* as = dynamic_cast<AggregateStat*>(s);
        auto err = [s](const char* reason) {
            panic("Stat %s is not per-core (%s)", s->name(), reason);
        };
        if (!as) err("not aggregate stat");
        if (!as->isRegular()) err("irregular aggregate");
        if (as->size() != zinfo->numCores) err("elems != cores");
    }

    // Initialize all the buffers
    bufSize = StatSize(coreStats);
    buf = gm_calloc<uint64_t>(bufSize);
    lastBuf = gm_calloc<uint64_t>(bufSize);

    // Create the procStats
    procStats = new AggregateStat(true);
    procStats->init("procStats", "Per-process stats");
    for (uint32_t p = 0; p < maxProcs; p++) {
        AggregateStat* ps = new AggregateStat(false);
        const char* name = gm_strdup(("procStats-" + Str(p)).c_str());
        ps->init(name, "Per-process stats");
        for (uint32_t i = 0; i < coreStats->size(); i++) {
            AggregateStat* as = dynamic_cast<AggregateStat*>(coreStats->get(i));
            assert(as && as->isRegular());
            ps->append(replStat(as->get(0), as->name(), as->desc()));
        }
        procStats->append(ps);
    }
    parentStat->append(procStats);
}
Esempio n. 28
0
AggregateStat* FilterStatsLevel(const AggregateStat* src, const regex& filter, const char* prefix) {
    string base = prefix? (string(prefix) + src->name() + ".") : ""; //if NULL prefix, omit our name (we're root)
    vector<Stat*> children;
    for (uint32_t i = 0; i < src->size(); i++) {
        Stat* child = src->get(i);
        if (AggregateStat* as = dynamic_cast<AggregateStat*>(child)) {
            AggregateStat* fs = FilterStatsLevel(as, filter, base.c_str());
            if (fs) children.push_back(fs);
        } else {
            string name = base + child->name();
            if (regex_match(name, filter)) children.push_back(child);
        }
    }

    if (children.size()) {
        AggregateStat* res = new AggregateStat(src->isRegular());
        res->init(src->name(), src->desc());
        for (Stat* c : children) res->append(c);
        return res;
    } else {
        return NULL;
    }
}
Esempio n. 29
0
void EntityAction::handleStat( Entity& entity ) {
    CStats* cStats = entity.get<CStats>();

    if( !cStats ) {
        return;
    }

    Stat* health = cStats->getStat( Stat::SID_Health );

    if( !health ) {
        return;
    }

    if( stat == EAStat_Damage ) {
        // Temp, min-max should be randomized in RNG
        if( health->change( -maxValue ) ) {
            // Temp, should be replaced by some message
            MSG_SYSTEM.send( c_msgEnemyDied, entity );
        }
    }
    else if( stat == EAStat_Heal ) {
        health->change( maxValue );
    }
}
Esempio n. 30
0
void OldLayoutResult::CheckAndCalcStat(scalar cutThickness, const Rect& rect, Stat* outStat) const
{
	Stat stat;
	stat.MakeZero();
	stat.Opilki += (double)rect.Size[!s] * (double)std::min(cutThickness, rect.Size[s] - (cut + cutThickness) * kratnostj + cutThickness);
	scalar detailsWithCutsLength = 0;
	unsigned cuts = 0;
	for(Details::const_iterator i = details.begin(); i != details.end(); i++)
	{
		detailsWithCutsLength += (i->size + cutThickness) * i->num;
		cuts += i->num;
	}
	stat.Opilki += ((cut + cutThickness) * kratnostj - cutThickness) * std::min(cutThickness, rect.Size[!s] - detailsWithCutsLength + cutThickness);
	stat.Opilki += (detailsWithCutsLength - cutThickness) * cutThickness * (kratnostj - 1);
	stat.Opilki += cut * cutThickness * (cuts - 1) * kratnostj;

	Stat remainStat;
	Rect remainRect;
	remainRect.Size[s] = std::max<scalar>((cut + cutThickness) * kratnostj - cutThickness, 0);
	remainRect.Size[!s] = std::max<scalar>(rect.Size[!s] - detailsWithCutsLength, 0);
	if(premain != 0)
	{
		premain->CheckAndCalcStat(cutThickness, remainRect, &remainStat);
	}
	else
	{
		remainStat.MakeZero();
		remainStat.AddScrap(remainRect);
	}
	stat += remainStat;
	Stat recurseStat;
	Rect recurseRect;
	recurseRect.Size[s] = std::max<scalar>(rect.Size[s] - (cut + cutThickness) * kratnostj, 0);
	recurseRect.Size[!s] = rect.Size[!s];
	if(precurse != 0)
	{
		precurse->CheckAndCalcStat(cutThickness, recurseRect, &recurseStat);
	}
	else
	{
		recurseStat.MakeZero();
		recurseStat.AddScrap(recurseRect);
	}
	stat += recurseStat;
	*outStat = stat;
}