예제 #1
0
void LoopOperator::forwardEstimation(
		boost::ptr_vector<MeshContext>& contextStack ,
		                        FitobCalculator* calc ,
		                        int& stackIndex ,
		                        double& timeStamp ){
	// see if the expression in the condition constant is
	// we use the context on the top of the stack
	MeshContext& actualContext = contextStack[stackIndex];
	FITOB_OUT_LEVEL3(verb(),"LoopOperator::forwardEstimation  Test if it is constant");
	bool constCondition_ = loopCondition_->isConstantExpression(actualContext);
	nrLoop_ = 0;
	if (constCondition_)
	{  // expression is constant, we calculate the LOOP count
		nrLoop_ = (int)(loopCondition_->eval(actualContext.minGlobCoord()));
	}
	else{
		FITOB_ERROR_EXIT(" Expression in the LOOP operator must be a constant (invariant) expression ");
	}

	// call the body N times
	for (int ind = 0; ind < nrLoop_ ; ind++){
		FITOB_OUT_LEVEL3(verb(),"LoopOperator::forwardEstimation bef. :" << stackIndex <<
			  " contextStack.size():" << contextStack.size() << " ind:"<<ind << " nrLoop:" << nrLoop_);
		loopBody_->forwardEstimation( contextStack , calc , stackIndex , timeStamp );
		FITOB_OUT_LEVEL3(verb(),"LoopOperator::forwardEstimation aft. :" << stackIndex <<
			  " contextStack.size():" << contextStack.size() << " ind:"<<ind << " nrLoop:" << nrLoop_);
	}
}
예제 #2
0
void llvm_model::set_prediction(const ObsId & obs_id, boost::ptr_vector<theta::Function> & coeffs_, boost::ptr_vector<HistogramFunction> & histos_){
    observables.insert(obs_id);
    const size_t n = coeffs_.size();
    if(n!=coeffs_.size()) throw invalid_argument("Model::setPrediction: number of histograms and coefficients do not match");
    if(histos[obs_id].size()>0 || coeffs[obs_id].size()>0)
        throw invalid_argument("Model::setPrediction: prediction already set for this observable");
    coeffs[obs_id].transfer(coeffs[obs_id].end(), coeffs_.begin(), coeffs_.end(), coeffs_);
    histos[obs_id].transfer(histos[obs_id].end(), histos_.begin(), histos_.end(), histos_);
    for(boost::ptr_vector<theta::Function>::const_iterator it=coeffs[obs_id].begin(); it!=coeffs[obs_id].end(); ++it){
        ParIds pids = (*it).get_parameters();
        parameters.insert(pids.begin(), pids.end());
    }
    size_t nbins = 0;
    double xmin = NAN, xmax = NAN;
    bool first = true;
    for(boost::ptr_vector<HistogramFunction>::const_iterator it=histos[obs_id].begin(); it!=histos[obs_id].end(); ++it){
        if(first){
            it->get_histogram_dimensions(nbins, xmin, xmax);
            first = false;
        }
        else{
            size_t nbins_tmp = 0;
            double xmin_tmp = NAN, xmax_tmp = NAN;
            it->get_histogram_dimensions(nbins_tmp, xmin_tmp, xmax_tmp);
            if(nbins!=nbins_tmp || xmin!=xmin_tmp || xmax!=xmax_tmp){
                throw invalid_argument("llvm_model::set_prediction: histogram dimensions mismatch");
            }
        }
        const ParIds & pids = (*it).get_parameters();
        parameters.insert(pids.begin(), pids.end());
    }
}
예제 #3
0
파일: main.cpp 프로젝트: fromtherussia/e2d
void renderScene() {
    FrameTimeCounter counter;
    int avgFps = 0;
    int iterations = 0;
    while (!complete) {
        counter.BeginCounting();

        physicsWorld->Simulate(1.0f / 10.0f);

        contextPtr->BeginScene();
        contextPtr->ApplyCamera(*cameraPtr);
        //contextPtr->RenderLine(vec2(0.0f, 0.0f), vec2(100.0f, 100.0f));
        for (int i = 0; i < physicsBodies.size(); ++i) {
            physicsBodies[i].DebugRender(debugRenderer);
        }

        for (int i = 0; i < physicsJoints.size(); ++i) {
            physicsJoints[i].DebugRender(debugRenderer);
        }

        contextPtr->EndScene();



        counter.EndCounting();

        avgFps += counter.GetFps();
        iterations++;
        if (iterations > 10) {
            SetWindowTextA(hWnd, formatString("fps: %d", avgFps / iterations).c_str());
            iterations = 0;
            avgFps = 0;
        }
    }
}
예제 #4
0
파일: wkb.cpp 프로젝트: GISpecialist/mapnik
bool geometry_utils::from_wkb(boost::ptr_vector<geometry_type>& paths,
                               const char* wkb,
                               unsigned size,
                               wkbFormat format)
{
    std::size_t geom_count = paths.size();
    wkb_reader reader(wkb, size, format);
    reader.read(paths);
    if (paths.size() > geom_count)
        return true;
    return false;
}
예제 #5
0
inline bool command::fetch(std::vector<variant>& row)
{
  if (0 == m_hnd.stmt) return false;
  if (m_cols.empty()) columns();

  const sword r(lib::singleton().p_OCIStmtFetch2(m_hnd.stmt, m_hnd.err, 1, OCI_FETCH_NEXT, 1, OCI_DEFAULT));
  if (OCI_NO_DATA == r) return false;
  m_hnd.check(r);

  row.resize(m_cols.size());
  for (size_t i(0); i < m_cols.size(); ++i)
    m_cols[i](row[i]);
  return true;
}
예제 #6
0
파일: command.hpp 프로젝트: respu/brig
inline bool command::fetch(std::vector<variant>& row)
{
  if (!m_stmt) return false;
  if (m_cols.empty()) columns();

  const int r(lib::singleton().p_mysql_stmt_fetch(m_stmt));
  if (MYSQL_NO_DATA == r) return false;
  check(1 != r);

  row.resize(m_cols.size());
  for (size_t i(0); i < m_cols.size(); ++i)
    check(m_cols[i](m_stmt, (unsigned int)i, row[i]) == 0);
  return true;
}
예제 #7
0
파일: command.hpp 프로젝트: respu/brig
inline bool command::fetch(std::vector<variant>& row)
{
  if (lib::error(m_req)) return false;
  if (m_cols.empty()) columns();

  const int r(lib::singleton().p_cci_cursor(m_req, 1, CCI_CURSOR_CURRENT, &m_err));
  if (CCI_ER_NO_MORE_DATA == r) return false;
  check(r);
  check(lib::singleton().p_cci_fetch(m_req, &m_err));

  row.resize(m_cols.size());
  for (size_t i(0); i < m_cols.size(); ++i)
    if (lib::error(m_cols[i](m_req, i, row[i]))) throw std::runtime_error("CUBRID error");
  return true;
}
예제 #8
0
const Value MessageSelectorEnv::specialValue(const string& id) const
{
    Value v;
    // TODO: Just use a simple if chain for now - improve this later
    if ( id=="delivery_mode" ) {
        v = msg.getEncoding().isPersistent() ? PERSISTENT : NON_PERSISTENT;
    } else if ( id=="redelivered" ) {
        v = msg.getDeliveryCount()>0 ? true : false;
    } else if ( id=="priority" ) {
        v = int64_t(msg.getPriority());
    } else if ( id=="correlation_id" ) {
        MessageId cId = msg.getEncoding().getCorrelationId();
        if (cId) {
            returnedStrings.push_back(new string(cId.str()));
            v = returnedStrings[returnedStrings.size()-1];
        }
    } else if ( id=="message_id" ) {
        MessageId mId = msg.getEncoding().getMessageId();
        if (mId) {
            returnedStrings.push_back(new string(mId.str()));
            v = returnedStrings[returnedStrings.size()-1];
        }
    } else if ( id=="to" ) {
        v = EMPTY; // Hard to get this correct for both 1.0 and 0-10
    } else if ( id=="reply_to" ) {
        v = EMPTY; // Hard to get this correct for both 1.0 and 0-10
    } else if ( id=="absolute_expiry_time" ) {
        qpid::sys::AbsTime expiry = msg.getExpiration();
        // Java property has value of 0 for no expiry
        v = (expiry==qpid::sys::FAR_FUTURE) ? 0
            : qpid::sys::Duration(qpid::sys::AbsTime::Epoch(), expiry) / qpid::sys::TIME_MSEC;
    } else if ( id=="creation_time" ) {
        // Use the time put on queue (if it is enabled) as 0-10 has no standard way to get message
        // creation time and we're not paying attention to the 1.0 creation time yet.
        v = int64_t(msg.getTimestamp() * 1000); // getTimestamp() returns time in seconds we need milliseconds
    } else if ( id=="jms_type" ) {
        // Currently we can't distinguish between an empty JMSType and no JMSType
        // We'll assume for now that setting an empty JMSType doesn't make a lot of sense
        const string jmsType = msg.getAnnotation("jms-type").asString();
        if ( !jmsType.empty() ) {
            returnedStrings.push_back(new string(jmsType));
            v = returnedStrings[returnedStrings.size()-1];
        }
    } else {
        v = Value();
    }
    return v;
}
예제 #9
0
double distance::getEuclidean2(boost::ptr_vector<double>& v1, boost::ptr_vector<double>& v2)
{
	double euclidean = 0;
	int n = v1.size() == v2.size() ? v1.size() : 0;
	if (n > 0)
	{
		for (boost::ptr_vector<double>::iterator it1 = v1.begin(), it2 = v2.begin(); it1 != v1.end(), it2 != v2.end(); it1++, it2++)
		{
			euclidean += (*it1 - *it2)*(*it1 - *it2);
		}
		euclidean = sqrt(euclidean);
		return euclidean;
	}
	else
		return (double)-1;
}
예제 #10
0
파일: Selector.cpp 프로젝트: ncdc/qpid
 void set(const string& id, const qb::Value& value) {
     if (value.type==qb::Value::T_STRING) {
         strings.push_back(new string(*value.s));
         values[id] = strings[strings.size()-1];
     } else {
         values[id] = value;
     }
 }
예제 #11
0
/** function for diffusion axis size (enlargement) estimation */
void LoopOperator::forwardEstimation_DiffusionEnlarement(
		                          boost::ptr_vector<MeshContext>& contextStack ,
		                          FitobCalculator* calc ,
		                          DVector& gradValues,
		                          int globalVariableIndex,
			                      int& stackIndex ,
		                          double timeStamp ) const {
	// if the index already below the index then nothing to do
	// this is the exit condition for instructions below "timeStamp"
	if ( stackIndex >= (int)contextStack.size() ) return; // EXIT IF NEEDED

	// call the body N times
	for (int ind = 0; ind < nrLoop_ ; ind++){
		loopBody_->forwardEstimation_DiffusionEnlarement( contextStack , calc , gradValues ,
				globalVariableIndex , stackIndex , timeStamp);
		FITOB_OUT_LEVEL3(verb(),"LoopOperator::forwardEstimation:" << stackIndex <<
			  " contextStack.size():" << contextStack.size() << " ind:"<<ind << " nrLoop:" << nrLoop_);
	}
}
예제 #12
0
typename Argc_T<CON>::type Argc_T<CON>::
getData(RLMachine& machine,
                     const boost::ptr_vector<libReallive::ExpressionPiece>& p,
                     unsigned int& position) {
  type return_vector;
  for (; position < p.size(); )
    return_vector.push_back(CON::getData(machine, p, position));

  return return_vector;
}
예제 #13
0
 void set_target(engine::pointer z){
     //cooltime();
     if (cooldown < 1){
         for(short i = 0; i < ammo.size(); i++){
             if (!ammo[i].fired){
                 ammo[i].fired = true;
                 break;
             }
         }
     }
 }
예제 #14
0
 void init(unsigned int thread_count)
 {
     voxel_data.resize(thread_count);
     for (unsigned int index = 0; index < thread_count; ++index)
     {
         voxel_data[index].space.resize(q_count);
         voxel_data[index].odf.resize(ti.half_vertices_count);
         voxel_data[index].fa.resize(max_fiber_number);
         voxel_data[index].dir_index.resize(max_fiber_number);
         voxel_data[index].dir.resize(max_fiber_number);
     }
     for (unsigned int index = 0; index < process_list.size(); ++index)
         process_list[index].init(*this);
 }
예제 #15
0
void ThetaOperator::forwardEstimation_DiffusionEnlarement(
		                          boost::ptr_vector<MeshContext>& contextStack ,
		                          FitobCalculator* calc ,
		                          DVector& gradValues,
		                          int globalVariableIndex,
			                      int& stackIndex ,
		                          double timeStamp ) const {
	// if the index already below the index then nothing to do
	// this is the exit condition for instructions below "timeStamp"
	if ( stackIndex >= (int)contextStack.size() ) return; // EXIT IF NEEDED

	// here we only increase the stack index
	stackIndex = stackIndex + 1;
}
예제 #16
0
    /// compute the resulting force of all force field objects.
    d_vector getObjForce(vrpn_float64 *pos, vrpn_float64 *vel) {
        int i;

        for (i=0; i<3; ++i) {
            m_curforce[i]=0.0;
            m_curpos[i]=pos[i];
            m_curvel[i]=vel[i];
        }

        // force field objects
        int nobj = m_FFEffects.size();
        for (i=0; i<nobj; ++i) {
            m_curforce = m_curforce + m_FFEffects[i].calcForce (m_curpos);
        }
        return m_curforce;
    };
예제 #17
0
 void thread_run(unsigned char thread_index,unsigned char thread_count,
                 const std::vector<unsigned char>& mask)
 {
     unsigned int sum_mask = std::accumulate(mask.begin(),mask.end(),(unsigned int)0)/thread_count;
     unsigned int cur = 0;
     for(unsigned int voxel_index = thread_index;
         voxel_index < dim.size() &&
         (thread_index != 0 || check_prog(cur,sum_mask));voxel_index += thread_count)
     {
         if (!mask[voxel_index])
             continue;
         cur += mask[voxel_index];
         voxel_data[thread_index].init();
         voxel_data[thread_index].voxel_index = voxel_index;
         for (int index = 0; index < process_list.size(); ++index)
             process_list[index].run(*this,voxel_data[thread_index]);
         if(prog_aborted())
             break;
     }
 }
예제 #18
0
void ThetaOperator::forwardEstimation(
		boost::ptr_vector<MeshContext>& contextStack ,
		                        FitobCalculator* calc ,
		                        int& stackIndex ,
		                        double& timeStamp ){

	FITOB_OUT_LEVEL3(verb(),"ThetaOperator::forwardEstimation stackIndex:" << stackIndex << "timeStamp"
			<< timeStamp << " contextStack.size():" << contextStack.size());

	MeshContext& actualContext = contextStack[stackIndex];

	if (thetaExpression_->isConstantExpression(actualContext) == false){
		FITOB_ERROR_EXIT(" ThetaOperator, theta expression is not constant ");
	}
    // evaluate the the expression (theta time) and store it
	thetaTime_ = thetaExpression_->eval(actualContext.minGlobCoord());

	// todo: these values now are not taken in consideration,
	// This might be a future feature, to split up one Theta operator in small theta operators
	// in case of too large macro time step
	// 19.09.2010 -> at todays knowledge this is not necessary, this would only make things worse
	maxThetaTime_ = 10.0; //calc->getXMLConfiguration().get()->getDoubleConfiguration("thetaconfigurations.solver.maxThetaStep.<xmlattr>.value" );
	nr_Theta_ = ceil(thetaTime_/maxThetaTime_);

	const boost::shared_ptr<ModelCollection>& factorModels = calc->getModelCollection();
	const boost::shared_ptr<ScriptModel>& scriptModel = calc->getScriptModel();
	const OperatorSequence& scriptBody = scriptModel->bodyOpSeq();
	const Domain& actDom = actualContext.getDom();
	int nrFactors = factorModels->nrFactors();

	Domain newDom(actDom);

	FITOB_OUT_LEVEL3(verb(),"ThetaOperator::forwardEstimation nrFactors:" << factorModels->nrFactors() << " thetaTime:" << thetaTime_ );
	for (int factorIndex = 0 ; factorIndex < nrFactors ; factorIndex++)
	{
		const FactorModelBase& model = factorModels->getModel(factorIndex);
		int globalIndex = model.getGlobalIndex();

		const DVector& startVal = calc->getStartDomain()->getGradedAxis(globalIndex);

		// get the points of the normal distribution
		DVector stdPoints;
		returnScaledNormalDistribution( actDom.getMaximalLevel() ,
				factorModels->stdFactor(factorIndex) , 1 ,  stdPoints );

		FITOB_OUT_LEVEL3(verb(),"ThetaOperator::forwardEstimation factorIndex:" << factorIndex << " P.size():" << stdPoints.size());
		// here we calculate the scaling
		if (startVal.size() > 1){
			for (unsigned int pointI = 0; pointI < stdPoints.size() ; pointI++ ){
				double endVal = 0.0;
				model.forwardEstimation(startVal[pointI] , timeStamp + thetaTime_ ,
						stdPoints[pointI] , actDom.getAverage() , endVal );
				if (verb()>3){
					std::cout << endVal << ",";
				}
				stdPoints[pointI] = endVal;
			}
			if (verb()>3) std::cout << std::endl;
		} else {
			for (unsigned int pointI = 0; pointI < stdPoints.size() ; pointI++ ){
				double endVal = 0.0;
				model.forwardEstimation(startVal[0] , timeStamp + thetaTime_ ,
						stdPoints[pointI] , actDom.getAverage() , endVal );
				if (verb()>3){
					std::cout << endVal << ",";
				}
				stdPoints[pointI] = endVal;
			}
			if (verb()>3) std::cout << std::endl;
		}

		//and call forwardEstimation_DiffusionEnlarement
		int stackIndex_tmp = 0;
		scriptBody.forwardEstimation_DiffusionEnlarement( contextStack ,
                calc ,stdPoints , globalIndex , stackIndex_tmp  , timeStamp );

		// sort stdPoints vector - not necessary (even in mean reversion case)
		// - this is not necessary since we estimate the values from 0 till T and not for dT
		std::sort( stdPoints.begin(),stdPoints.end() );

		// set the axis in the new domain
		newDom.setAxis(stdPoints,globalIndex);
	}

	// add new context, extend contextStack
	contextStack.push_back(new MeshContext(newDom,timeStamp));
	FITOB_OUT_LEVEL3(verb(),"ThetaOperator::forwardEstimation New Domain:" << newDom.toString() );
	timeStamp = timeStamp + thetaTime_;
	stackIndex = stackIndex + 1;

}
예제 #19
0
 void end(MatFile& writer)
 {
     for (unsigned int index = 0; index < process_list.size(); ++index)
         process_list[index].end(*this,writer);
 }
예제 #20
0
std::pair<size_t, size_t> tune_params(
        const double* divs, size_t num_bags,
        const std::vector<label_type> &labels,
        const boost::ptr_vector<Kernel> &kernels,
        const std::vector<double> &c_vals,
        const svm_parameter &svm_params,
        size_t folds,
        size_t num_threads)
{
    typedef std::pair<size_t, size_t> config;

    size_t num_kernels = kernels.size();

    if (num_kernels == 0) {
        BOOST_THROW_EXCEPTION(std::domain_error(
                    "no kernels in the kernel group"));
    } else if (num_kernels == 1 && c_vals.size() == 1) {
        // only one option, we already know what's best
        return config(0, 0);
    }


    // want to be able to take sub-lists of kernels.
    // this is like c_array(), but constness is slightly different and
    // it works in old, old boosts.
    const Kernel * const * kern_array =
        reinterpret_cast<const Kernel* const*>(&kernels.begin().base()[0]);

    // how many threads are we using?
    num_threads = npdivs::get_num_threads(num_threads);
    if (num_threads > num_kernels)
        num_threads = num_kernels;

    if (num_threads == 1) {
        // don't actually make a new thread if it's just 1-threaded
        double score;
        return pick_rand(tune_params_single(divs, num_bags, labels,
                    kern_array, num_kernels, c_vals, svm_params, folds,
                    &score));
    }

    // grunt work to set up multithreading
    boost::ptr_vector< tune_params_worker<label_type> > workers;
    std::vector<boost::exception_ptr> errors(num_threads);
    boost::thread_group worker_threads;

    std::vector< std::vector<config> > results(num_threads);
    std::vector<double> scores(num_threads, 0);

    size_t kerns_per_thread = (size_t)
            std::ceil(double(num_kernels) / num_threads);
    size_t kern_start = 0;

    // give each thread a few kernels and get their most-accurate configs
    // TODO: better allocation algo
    for (size_t i = 0; i < num_threads; i++) {
        int n_kerns =
            (int)(std::min(kern_start+kerns_per_thread, num_kernels))
            - (int)(kern_start);

        if (n_kerns <= 0)
            break;

        workers.push_back(new tune_params_worker<label_type>(
                    divs, num_bags, labels,
                    kern_array + kern_start, n_kerns,
                    c_vals, svm_params, folds,
                    &results[i], &scores[i],
                    errors[i]
        ));

        worker_threads.create_thread(boost::ref(workers[i]));

        kern_start += kerns_per_thread;
    }
    worker_threads.join_all();
    for (size_t i = 0; i < num_threads; i++)
        if (errors[i])
            boost::rethrow_exception(errors[i]);

    // get all the best configs into one vector
    double best_score = *std::max_element(
            scores.begin(), scores.end());
    std::vector<config> best_configs;

    if (best_score == -std::numeric_limits<double>::infinity()) {
        FILE_LOG(logERROR) << "all kernels were terrible";
        BOOST_THROW_EXCEPTION(std::domain_error("all kernels were terrible"));
    }

    kern_start = 0;
    for (size_t i = 0; i < num_threads; i++) {
        if (scores[i] == best_score) {
            for (size_t j = 0; j < results[i].size(); j++) {
                config cfg = results[i][j];
                best_configs.push_back(
                        config(cfg.first + kern_start, cfg.second));
            }
        }
        kern_start += kerns_per_thread;
    }

    return pick_rand(best_configs);
}
예제 #21
0
void SnpEstimation::result(const boost::ptr_vector<Snp> &snpList, const boost::ptr_vector<Region> &regionList){
    bool sign = !(snpList.front().getSign()==0);
    double i2 = (m_bt)? usefulTools::dnorm(usefulTools::qnorm(m_prevalence))/(m_prevalence): 0;
    i2 = i2*i2;
    double adjust = 0.0;
    size_t countNum  = 0;
    double sampleSize = 0.0;
    std::vector<double> heritability;
    std::vector<double> variance;
    std::vector<double> effective;
    for(size_t i = 0; i < regionList.size(); ++i){
        // add stuff
        heritability.push_back(0.0);
        variance.push_back(regionList[i].getVariance());
        effective.push_back(0.0);
    }
    std::ofstream fullOutput;
    bool requireFullOut = false;
    if(!m_output.empty()) requireFullOut = true;
    if(requireFullOut){
        std::string fullOutName = m_output;
        fullOutName.append(".res");
        fullOutput.open(fullOutName.c_str());
        if(!fullOutput.is_open()){
            requireFullOut = false;
            fprintf(stderr, "Cannot access output file: %s\n", fullOutName.c_str());
            fprintf(stderr, "Will only provide basic output\n");
        }
        else{
            fullOutput << "Chr\tLoc\trsID\tZ\tF\tH\tStatus" << std::endl;
        }
    }
    for(size_t i = 0; i < snpList.size(); ++i){
        if(requireFullOut){
            fullOutput << snpList[i].getChr() << "\t" << snpList[i].getLoc() << "\t" << snpList[i].getRs() << "\t" << snpList[i].getTStat() << "\t"<< snpList[i].getFStat() << "\t" << snpList[i].getHeritability() << "\t" << snpList[i].getStatus() << std::endl;
        }
        for(size_t j = 0; j < regionList.size(); ++j){
//            if(j ==0) std::cerr << snpList[i].flag(j) << std::endl;
            if(snpList[i].flag(j)) heritability[j]+=snpList[i].getHeritability();
            if(snpList[i].flag(j)) effective[j] += snpList[i].getEffective();
        }
        sampleSize +=(double)(snpList[i].getSampleSize());
        countNum++;
        if(m_bt){
            double portionCase = (double)(snpList[i].getNCase()) / (double)(snpList[i].getSampleSize());
            adjust+= ((1.0-m_prevalence)*(1.0-m_prevalence))/(i2*portionCase*(1-portionCase));
        }

    }

    if(requireFullOut) fullOutput.close();

    double adjustment = adjust/(double)countNum; // we use the average adjustment value here
    if(!m_bt) adjustment = m_extreme;
    double averageSampleSize = sampleSize/(double)countNum;
    if(!m_output.empty()) requireFullOut =true;
    std::ofstream sumOut;
    if(requireFullOut){
        std::string sumOutName = m_output;
        sumOutName.append(".sum");
        sumOut.open(sumOutName.c_str());
        if(!sumOut.is_open()){
            fprintf(stderr, "Cannot access output file %s\n", sumOutName.c_str());
            fprintf(stderr, "Will output to stdout instead\n");
            requireFullOut=false;
        }
    }
    // We separate it, because it is possible for the previous if to change the requireFullOut flag
    if(!requireFullOut){
        // Only output to the stdout
        std::cout << "Region\tHeritability\tVariance" << std::endl;
        for(size_t i = 0; i < regionList.size(); ++i){
            std::cout << regionList[i].getName() << "\t" << adjustment*heritability[i] << "\t";
            if(!sign) std::cout << adjustment*(2.0*(effective[i]*adjustment*adjustment+2.0*adjustment*heritability[i]*averageSampleSize)/(averageSampleSize*averageSampleSize)) << std::endl;
            else std::cout << adjustment*adjustment*variance[i] << std::endl;
        }
    }
    else{
        sumOut << "Region\tHeritability\tVariance" << std::endl;
        std::cout << "Region\tHeritability\tVariance" << std::endl;
        for(size_t i = 0; i < regionList.size(); ++i){
            sumOut << regionList[i].getName() << "\t" << adjustment*heritability[i] << "\t";
            std::cout << regionList[i].getName() << "\t" << heritability[i] << "\t";
            if(!sign){ // We use effective number
                sumOut << adjustment*(2.0*(effective[i]*adjustment*adjustment+2.0*adjustment*heritability[i]*averageSampleSize)/(averageSampleSize*averageSampleSize)) << std::endl;
                std::cout << adjustment*(2.0*(effective[i]*adjustment*adjustment+2.0*adjustment*heritability[i]*averageSampleSize)/(averageSampleSize*averageSampleSize)) << std::endl;
            }
            else{
                sumOut << adjustment*adjustment*variance[i] << std::endl;
                std::cout << adjustment*adjustment*variance[i] << std::endl;
            }
        }
        sumOut.close();
    }
}
예제 #22
0
파일: Selector.cpp 프로젝트: ncdc/qpid
 void set(const string& id, const char* value) {
     strings.push_back(new string(value));
     values[id] = strings[strings.size()-1];
 }
예제 #23
0
    unsigned num_geometries() const
    {
	return geom_cont_.size();
    }
예제 #24
0
void SnpEstimation::estimate(GenotypeFileHandler &genotypeFileHandler, boost::ptr_vector<Snp> &snpList, boost::ptr_vector<Region> &regionList){
    // This contains the genotypes from the reference panel, the main container for this function
    boost::ptr_deque<Genotype> genotype;
    // This contains the index of the SNPs included in the genotype
    std::deque<size_t> snpLoc;
    // This should be invoked when we came to the end of chromosome / region
    bool windowEnd = false;
    // Initialize the linkage and decompose
    Linkage linkage(m_thread);
    Decomposition decompose(m_thread);
    fprintf(stderr, "Estimate SNP heritability\n\n");

    size_t doneItems = 0;
    size_t totalSnp = snpList.size();
    std::string chr = "";

    // This is use for indicating whether if the whole genome is read
    bool completed = false;
    std::vector<size_t> boundary;
    bool starting = true;
    size_t checking = 0; //DEBUG
    while(!completed){
        // Keep doing this until the whole genome is read
        progress(doneItems, totalSnp, chr);
        // only used when the finalizeBuff is true, this indicate whether if the last block is coming from somewhere new
        bool retainLastBlock=false;
        while(boundary.size() < 5 && !completed && !windowEnd){
            genotypeFileHandler.getBlock(snpList, genotype, snpLoc, windowEnd, completed,boundary, false);
            bool boundChange = false;
            linkage.construct(genotype, snpLoc, boundary, snpList, m_ldCorrection, boundChange);

            if(boundChange && boundary.back()==snpLoc.size()){
                    windowEnd=true;
                    boundary.pop_back();
            }
            else if(boundChange&&snpList.at(snpLoc[boundary.back()]).getLoc()- snpList.at(snpLoc[boundary.back()-1]).getLoc() > m_blockSize){
                    retainLastBlock = true;
                    windowEnd=true;
            }
            genotypeFileHandler.getBlock(snpList, genotype, snpLoc, windowEnd, completed,boundary, true);
            linkage.construct(genotype, snpLoc, boundary, snpList, m_ldCorrection, boundChange);
        }
        if(windowEnd && !retainLastBlock && boundary.size() > 2){ //Check whether if we need to merge the two blocks
            size_t indexOfLastSnpOfSecondLastBlock = snpLoc.at(boundary.back()-1); // just in case
            size_t lastSnp = snpLoc.back();
            if(snpList.at(lastSnp).getLoc()-snpList.at(indexOfLastSnpOfSecondLastBlock).getLoc() <= m_blockSize){
                boundary.pop_back();
                bool boundChange=false;
                linkage.construct(genotype, snpLoc, boundary, snpList, m_ldCorrection, boundChange);
            }
        }
        if(retainLastBlock && !windowEnd) throw std::runtime_error("Impossible combination of windowEnd and retain last block!");
        decompose.run(linkage, snpLoc, boundary, snpList, windowEnd, !retainLastBlock, starting, regionList);
        doneItems= snpLoc.at(boundary.back());
        chr = snpList[snpLoc[boundary.back()]].getChr();

        if(retainLastBlock){
            // Then we must remove everything except the last block
            // because finalizeBuff must be true here
            size_t update = boundary.back();
            genotype.erase(genotype.begin(), genotype.begin()+update);
            snpLoc.erase(snpLoc.begin(), snpLoc.begin()+update);
            boundary.clear();
            boundary.push_back(0);
            linkage.clear(update);
            starting = true;
            windowEnd = false;
            retainLastBlock = false;
        }
        else if(windowEnd){
            snpLoc.clear();
            boundary.clear();
            genotype.clear();
            linkage.clear();
            starting = true;
            windowEnd = false;
            retainLastBlock = false;
        }
        else{
            starting = false;
            size_t update=boundary[1];
            genotype.erase(genotype.begin(), genotype.begin()+update);
            snpLoc.erase(snpLoc.begin(), snpLoc.begin()+update);
            linkage.clear(update);
            for(size_t i = 0; i < boundary.size()-1; ++i) boundary[i] = boundary[i+1]-update;
            boundary.pop_back();
        }
    }
    progress(totalSnp, totalSnp, "");
    fprintf(stderr, "\n\nEstimated the SNP Heritability, now proceed to output\n");
}
예제 #25
0
void MeshAssigmentOperator::backwardCalculation(
		boost::ptr_vector<MeshContext>& contextStack ,
		                          FitobCalculator* calc ,
			                      int& stackIndex ,
		                          double& timeStamp ){
	FITOB_OUT_LEVEL3(verb(),"MeshAssigmentOperator::backwardCalculation stackIndex:" << stackIndex << " contextStack.size():" << contextStack.size()
			<< "  timeStamp:" << timeStamp );
	FITOB_OUT_LEVEL3(verb(),"MeshAssigmentOperator::backwardCalculation Domain:" << contextStack[stackIndex].getDom().toString() );

    // if we get here then we just have a simple mesh assignment , no if condition will be considered here
	contextStack[stackIndex].getMesh()->setValues(
			assignExpression_ , contextStack[stackIndex].minGlobCoord());

	//apply constraints
	DVector globCoord = contextStack[stackIndex].getDom().getAverage();
	contextStack[stackIndex].getMesh()->applyConstraints( &(calc->getScriptModel().get()->constrainOpSeq()) , globCoord );

	// do eventually plotting
	calc->getPlotter()->plot( &(contextStack[stackIndex]) , calc->getScriptModel()->getModelName() );
}