size_t integrate_adaptive(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , dense_output_stepper_tag )
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;

    size_t count = 0;
    st.initialize( start_state , start_time , dt );

    while( less_with_sign( st.current_time() , end_time , st.current_time_step() ) )
    {
        while( less_eq_with_sign( static_cast<Time>(st.current_time() + st.current_time_step()) ,
               end_time ,
               st.current_time_step() ) )
        {   //make sure we don't go beyond the end_time
            obs( st.current_state() , st.current_time() );
            st.do_step( system );
            ++count;
        }
        // calculate time step to arrive exactly at end time
        st.initialize( st.current_state() , st.current_time() , end_time - st.current_time() );
    }
    obs( st.current_state() , st.current_time() );
    // overwrite start_state with the final point
    boost::numeric::odeint::copy( st.current_state() , start_state );
    return count;
}
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , stepper_tag 
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
    
    Time time = start_time;
    int step = 0;
    // cast time+dt explicitely in case of expression templates (e.g. multiprecision)
    while( less_eq_with_sign( static_cast<Time>(time+dt) , end_time , dt ) )
    {
        obs( start_state , time );
        st.do_step( system , start_state , time , dt );
        // direct computation of the time avoids error propagation happening when using time += dt
        // we need clumsy type analysis to get boost units working here
        ++step;
        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt;
    }
    obs( start_state , time );

    return step;
}
Ejemplo n.º 3
0
void cons(){
	int i,j,k;
	pos t,tn,t0,t1,t2,t3;
	for(i=0;i<MN;i++)for(j=0;j<MN;j++){
		t.y=i;t.x=j;
		//printf("%c ",frt[i][j]);
		switch(frt[i][j]){
			case 'F':
			case 'C':{
				if(frt[i][j]=='F'){frm.y=i;frm.x=j;}
				if(frt[i][j]=='C'){cow.y=i;cow.x=j;}
			}
			case '.':{
				for(k=0;k<4;k++){
					t0=nbr(t,k);
					t1=nbr(t,(k+1)%4);
					t2=nbr(t,(k+2)%4);
					t3=nbr(t,(k+3)%4);
					
					if(!obs(t2))
						edg[nod[i][j][k]][nod[t2.y][t2.x][k]]=1;
					if(obs(t2)&&!obs(t3))
						edg[nod[i][j][k]][nod[t3.y][t3.x][(k+1)%4]]=2;
					if(obs(t2)&&obs(t3)&&!obs(t0))
						edg[nod[i][j][k]][nod[t0.y][t0.x][(k+2)%4]]=3;
					if(obs(t2)&&obs(t3)&&obs(t0)&&!obs(t1))
						edg[nod[i][j][k]][nod[t1.y][t1.x][(k+3)%4]]=4;
				}								
				break;
			}
			case '*':break;
		};
	}
}
size_t integrate_adaptive(
        Stepper stepper , System system , State &start_state ,
        Time &start_time , Time end_time , Time &dt ,
        Observer observer , controlled_stepper_tag
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;

    const size_t max_attempts = 1000;
    const char *error_string = "Integrate adaptive : Maximal number of iterations reached. A step size could not be found.";
    size_t count = 0;
    while( less_with_sign( start_time , end_time , dt ) )
    {
        obs( start_state , start_time );
        if( less_with_sign( end_time , start_time + dt , dt ) )
        {
            dt = end_time - start_time;
        }

        size_t trials = 0;
        controlled_step_result res = success;
        do
        {
            res = st.try_step( system , start_state , start_time , dt );
            ++trials;
        }
        while( ( res == fail ) && ( trials < max_attempts ) );
        if( trials == max_attempts ) throw std::overflow_error( error_string );

        ++count;
    }
    obs( start_state , start_time );
    return count;
}
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , controlled_stepper_tag 
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    
    Time time = start_time;
    const Time time_step = dt;
    int real_steps = 0;
    int step = 0;
    
    while( less_eq_with_sign( static_cast<Time>(time+time_step) , end_time , dt ) )
    {
        obs( start_state , time );
        real_steps += detail::integrate_adaptive( stepper , system , start_state , time , time+time_step , dt ,
                                    null_observer() , controlled_stepper_tag() );
        // direct computation of the time avoids error propagation happening when using time += dt
        // we need clumsy type analysis to get boost units working here
        step++;
        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * time_step;
    }
    obs( start_state , time );

    return real_steps;
}
	void CHemlockLooperModel::AddDailyResult(const StringVector& header, const StringVector& data)
	{
		enum TInputAllStage{ E_NAME, E_ID, E_YEAR, E_MONTH, E_DAY, E_JDAY, E_CUMUL_L1, E_CUMUL_L2, E_CUMUL_L3, E_CUMUL_L4, E_CUMUL_PUPA, E_CUMUL_ADULT, NB_INPUT, NB_COLUMN = NB_INPUT + 7 };
		enum TInputPupasion{ P_NAME, P_ID, P_YEAR, P_MONTH, P_DAY, P_NB_DAYS, P_N, NB_INPUT_PUPAISON };

		CTRef TRef(ToInt(data[E_YEAR]), ToSizeT(data[E_MONTH]) - 1, ToSizeT(data[E_DAY]) - 1);

		if (header.size() == NB_COLUMN)
		{
			std::vector<double> obs(NB_INPUT - E_CUMUL_L1);

			for (size_t i = 0; i < obs.size(); i++)
				obs[i] = ToDouble(data[E_CUMUL_L1 + i]);

			m_SAResult.push_back(CSAResult(TRef, obs));
		}
		else if (header.size() == NB_INPUT_PUPAISON)
		{
			std::vector<double> obs(2);

			obs[PUP_NB_DAYS] = ToDouble(data[P_NB_DAYS]);
			obs[PUP_N] = ToDouble(data[P_N]);

			m_SAResult.push_back(CSAResult(TRef, obs));
		}
	}
Ejemplo n.º 7
0
size_t integrate_adaptive(
        Stepper stepper , System system , State &start_state ,
        Time &start_time , Time end_time , Time &dt ,
        Observer observer , controlled_stepper_tag
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;

    failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
    size_t count = 0;
    while( less_with_sign( start_time , end_time , dt ) )
    {
        obs( start_state , start_time );
        if( less_with_sign( end_time , static_cast<Time>(start_time + dt) , dt ) )
        {
            dt = end_time - start_time;
        }

        controlled_step_result res;
        do
        {
            res = st.try_step( system , start_state , start_time , dt );
            fail_checker();  // check number of failed steps
        }
        while( res == fail );
        fail_checker.reset();  // if we reach here, the step was successful -> reset fail checker

        ++count;
    }
    obs( start_state , start_time );
    return count;
}
Ejemplo n.º 8
0
Type objective_function<Type>::operator() ()
{
    DATA_MATRIX(obs);
    DATA_MATRIX(coord);
    DATA_VECTOR(covObs);
    DATA_INTEGER(p);
    DATA_VECTOR(h);

    PARAMETER(logObsSd);
    PARAMETER(logObsTSd);
    PARAMETER(logStatSd);
    PARAMETER_MATRIX(x);

    Type nll = 0.0;
    covafill<Type> cf(coord,covObs,h,p);

    // Contribution from states
    for(int i = 1; i < x.cols(); ++i) {
        nll -= dnorm(x(0,i), x(0,i-1), exp(logStatSd),true);
        nll -= dnorm(x(1,i), x(1,i-1), exp(logStatSd),true);
    }

    // contribution from observations
    for(int i = 0; i < obs.cols(); ++i) {
        nll -= dnorm(obs(0,i), x(0,i), exp(logObsSd),true);
        nll -= dnorm(obs(1,i), x(1,i), exp(logObsSd),true);
        vector<Type> tmp = x.col(i);
        Type val = evalFill((CppAD::vector<Type>)tmp, cf)[0];
        nll -= dnorm(obs(2,i), val, exp(logObsTSd),true);
    }


    return nll;
}
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , dense_output_stepper_tag 
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
    
    Time time = start_time;
    
    st.initialize( start_state , time , dt );
    obs( start_state , time );
    time += dt;

    int obs_step( 1 );
    int real_step( 0 );
    
    while( less_with_sign( static_cast<Time>(time+dt) , end_time , dt ) )
    {
        while( less_eq_with_sign( time , st.current_time() , dt ) )
        {
            st.calc_state( time , start_state );
            obs( start_state , time );
            ++obs_step;
            // direct computation of the time avoids error propagation happening when using time += dt
            // we need clumsy type analysis to get boost units working here
            time = start_time + static_cast< typename unit_value_type<Time>::type >(obs_step) * dt;
        }
        // we have not reached the end, do another real step
        if( less_with_sign( static_cast<Time>(st.current_time()+st.current_time_step()) ,
                            end_time ,
                            st.current_time_step() ) )
        {
            while( less_eq_with_sign( st.current_time() , time , dt ) )
            {
                st.do_step( system );
                ++real_step;
            }
        }
        else if( less_with_sign( st.current_time() , end_time , st.current_time_step() ) )
        { // do the last step ending exactly on the end point
            st.initialize( st.current_state() , st.current_time() , end_time - st.current_time() );
            st.do_step( system );
            ++real_step;
        }
        
    }
    // last observation, if we are still in observation interval
    if( less_eq_with_sign( time , end_time , dt ) )
    {
        st.calc_state( time , start_state );
        obs( start_state , time );
    }
    
    return real_step;
}
Ejemplo n.º 10
0
Time integrate_n_steps(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time dt , size_t num_of_steps ,
        Observer observer , dense_output_stepper_tag )
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;

    Time time = start_time;
    const Time end_time = start_time + static_cast< typename unit_value_type<Time>::type >(num_of_steps) * dt;

    st.initialize( start_state , time , dt );

    size_t step = 0;

    while( step < num_of_steps )
    {
        while( less_with_sign( time , st.current_time() , st.current_time_step() ) )
        {
            st.calc_state( time , start_state );
            obs( start_state , time );
            ++step;
            // direct computation of the time avoids error propagation happening when using time += dt
            // we need clumsy type analysis to get boost units working here
            time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt;
        }

        // we have not reached the end, do another real step
        if( less_with_sign( static_cast<Time>(st.current_time()+st.current_time_step()) ,
                            end_time ,
                            st.current_time_step() ) )
        {
            st.do_step( system );
        }
        else if( less_with_sign( st.current_time() , end_time , st.current_time_step() ) )
        { // do the last step ending exactly on the end point
            st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) );
            st.do_step( system );
        }
    }

    while( st.current_time() < end_time )
    {
        if( less_with_sign( end_time ,
                            static_cast<Time>(st.current_time()+st.current_time_step()) ,
                            st.current_time_step() ) )
            st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) );
        st.do_step( system );
    }

    // observation at end point, only if we ended exactly on the end-point (or above due to finite precision)
    obs( st.current_state() , end_time );

    return time;
}
size_t integrate_times(
        Stepper stepper , System system , State &start_state ,
        TimeIterator start_time , TimeIterator end_time , Time dt ,
        Observer observer , dense_output_stepper_tag
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;

    typedef typename unit_value_type<Time>::type time_type;

    if( start_time == end_time )
        return 0;

    TimeIterator last_time_iterator = end_time;
    --last_time_iterator;
    Time last_time_point = static_cast<time_type>(*last_time_iterator);

    st.initialize( start_state , *start_time , dt );
    obs( start_state , *start_time++ );

    size_t count = 0;
    while( start_time != end_time )
    {
        while( ( start_time != end_time ) && less_eq_with_sign( static_cast<time_type>(*start_time) , st.current_time() , st.current_time_step() ) )
        {
            st.calc_state( *start_time , start_state );
            obs( start_state , *start_time );
            start_time++;
        }

        // we have not reached the end, do another real step
        if( less_eq_with_sign( st.current_time() + st.current_time_step() ,
                               last_time_point ,
                               st.current_time_step() ) )
        {
            st.do_step( system );
            ++count;
        }
        else if( start_time != end_time )
        { // do the last step ending exactly on the end point
            st.initialize( st.current_state() , st.current_time() , last_time_point - st.current_time() );
            st.do_step( system );
            ++count;
        }
    }
    return count;
}
void singlePlanner::setObstacles(const std::vector<Vector> &obstacles)
{
  //obsSet.resize(obstacles.size());
  region *obstacle;
  for(int j=0; j<obstacles.size(); j++)
    {
      obstacle = new region;
      obstacle->setNumDimensions(nDim);
      Vector obs(2*nDim,0.0);
      for (int i=0; i<nDim; i++)
        {
          obstacle->center[i] = obstacles[j][i];
          obstacle->size[i] = obstacles[j][i+3];
          obs[i]=obstacles[j][i];
          obs[i+3]=obstacles[j][i+3];
        }
      system.obstacles.push_front(obstacle);
      obsSet.push_back(obs);
    }
//  cout<<"data in obsSet "<<endl;
//  for (int j=0; j<obsSet.size(); j++)
//    {
//      printf("Obstacle [%i] = [%g,%g,%g,%g,%g,%g]\n",
//         j, obsSet[j][0], obsSet[j][1], obsSet[j][2],
//      obsSet[j][3], obsSet[j][4], obsSet[j][5]);
//    }
//    cout<<endl;
//  rrts.setSystem(system);
}
Ejemplo n.º 13
0
void Casan::check_observed_resources (Msg &out)
{
    Resource *res ;
    reslist *rl ;

    for (rl = reslist_ ; rl != NULL ; rl = rl->next)
    {
	res = rl->res ;
	if (res->check_trigger ())
	{
	    DBG1 (F (B_BLUE "Observed resource '")) ;
	    DBG1 (rl->res->name ()) ;
	    DBG1 (F ("' triggered" C_RESET)) ;
	    DBGLN0 () ;

	    out.reset () ;

	    out.set_type (COAP_TYPE_ACK) ;
	    out.set_token (res->get_token ()) ;
	    out.set_id (curid_++) ;
	    out.set_code (COAP_CODE_OK) ;

	    option obs (option::MO_Observe, res->next_serial ()) ;
	    out.push_option (obs) ;

	    request_resource (NULL, &out, res) ;

	    out.send (*master_) ;
	}
    }
}
Ejemplo n.º 14
0
void testObservations() {
  printf("== TEST OBSERVATIONS ==\n");
  printf("- Testing construction\n");
  RLObservation obs(3);
  RLObservation obs2(3);
  for (int i=0; i<3; i++) {
    obs[i] = observation[i];
    obs2[i] = observation2[i];
  }
  printf("-> PASSED\n");

  printf("- Testing [] operator\n");
  for (int i=0; i<3; i++) {
    printf("%f %f\n", obs.observations[i], observation[i]);
    assert( obs[i] == observation[i] );
  }
  printf("-> PASSED\n");

  printf("- Testing copyFrom\n");
  obs.copyFrom(obs2);
  for (int i=0; i<3; i++)
    assert( obs[i] == observation2[i] );
  printf("-> PASSED\n");

}
Ejemplo n.º 15
0
	bool operator()(KMInput & input) {
		bool improvement(false);
		input.computeDistances();
		//		IntVector tLabel(input.getK(), 0);
		//		_v.allocate(input.nbObs(), input.getK());
		//		for (size_t obs(0); obs < input.nbObs(); ++obs) {
		//			for (size_t j(0); j < input.getK(); ++j) {
		//				_v.get(obs, j) = input.getDelta(obs, j);
		//			}
		//		}
		do {
			++input.ite();
			improvement = false;
			for (size_t obs(0); obs < input.nbObs(); ++obs) {
				std::pair<size_t, Double> const delta(input.getBest(obs));
				if (delta.second < 0) {
					input.cost() += delta.second;
					input.shift(obs, delta.first);
					improvement = true;
				}
			}
			if (improvement && isTraceOn)
				input.out("KMEANS");

		} while (improvement);
		return improvement;
	}
Ejemplo n.º 16
0
TEST(Account, shouldTriggerMemberObserverEvents) {
  // given
  Account acc;
  MockModelObserver obs(acc);

  {
    InSequence dummy;

    EXPECT_CALL(obs, willChange("name"));
    EXPECT_CALL(obs, didChange("name"));

    EXPECT_CALL(obs, willChange("descr"));
    EXPECT_CALL(obs, didChange("descr"));

    EXPECT_CALL(obs, willChange("type"));
    EXPECT_CALL(obs, didChange("type"));
  }

  // when
  acc.setName("A name");
  acc.setDescr("A descr");
  acc.setType(Account::AccountType::Asset);

  // then
  // mock expectations implicitly verified
}
Ejemplo n.º 17
0
int main() {
  // Run IRIS with the required_containment_points including a point which is outside the feasible set, which should result in an empty polyhedron

  iris::IRISProblem problem(2);
  problem.setSeedPoint(Eigen::Vector2d(0.1, 0.1));

  Eigen::MatrixXd obs(2,2);
  // Inflate a region inside a 1x1 box
  obs << 0, 1,
         0, 0;
  problem.addObstacle(obs);
  obs << 1, 1,
         0, 1;
  problem.addObstacle(obs);
  obs << 1, 0,
         1, 1;
  problem.addObstacle(obs);
  obs << 0, 0,
         1, 0;
  problem.addObstacle(obs);

  iris::IRISOptions options;
  options.require_containment = true;
  options.required_containment_points = {Eigen::Vector2d(1.5, 1.5)};

  auto region = inflate_region(problem, options);
  if (region->polyhedron->getNumberOfConstraints() > 0) {
    throw std::runtime_error("polyhedron should be empty");
  }

  return 0;
}
Ejemplo n.º 18
0
bool GridDetector::initCameraGeometryFromObservations(boost::shared_ptr<std::vector<cv::Mat> > images_ptr) {

  std::vector<cv::Mat>& images = *images_ptr;

  SM_DEFINE_EXCEPTION(Exception, std::runtime_error);
  SM_ASSERT_TRUE(Exception, images.size() != 0, "Need min. one image");

  std::vector<GridCalibrationTargetObservation> observations;

  for(unsigned int i=0; i<images.size(); i++)
  {
    GridCalibrationTargetObservation obs(_target);

    //detect calibration target
    bool success = findTargetNoTransformation(images[i], obs);

    //delete image copy (save memory)
    obs.clearImage();

    //append
    if(success)
      observations.push_back(obs);
  }

  //initialize the intrinsics
  if(observations.size() > 0)
    return _geometry->initializeIntrinsics(observations);

  return false;
}
Ejemplo n.º 19
0
int main(int argc, char** argv) {
  iris::IRISProblem problem(2);
  problem.setSeedPoint(Eigen::Vector2d(0.1, 0.1));

  Eigen::MatrixXd obs(2,2);
  // Inflate a region inside a 1x1 box
  obs << 0, 1,
         0, 0;
  problem.addObstacle(obs);
  obs << 1, 1,
         0, 1;
  problem.addObstacle(obs);
  obs << 1, 0,
         1, 1;
  problem.addObstacle(obs);
  obs << 0, 0,
         1, 0;
  problem.addObstacle(obs);

  iris::IRISOptions options;
  iris::IRISRegion region = inflate_region(problem, options);

  std::cout << "C: " << region.ellipsoid.getC() << std::endl;
  std::cout << "d: " << region.ellipsoid.getD() << std::endl;
  return 0;
}
Ejemplo n.º 20
0
int haplotypeCluster::closestN(int N, int clusteridx,
                               vector<pair<int, float> > &output) {

  output.resize(N);
  int count = 0;
  float d, maxdist = -1.0;
  int maxind = -1;

  for (int i = 0; i < nhap; i++) {
    if (cluster_mask[i]) {
      d = euc(i, clusteridx, mu, dlook);
      pair<int, float> obs(i, d);
      if (count < N) {
        output[count] = obs;
        if (obs.second > maxdist) {
          maxdist = obs.second;
          maxind = count;
        }
      } else if (obs.second > maxdist) {
        output[maxind] = obs;
        maxind = 0;
        for (int j = 1; j < N; j++)
          if (output[j].second > output[maxind].second)
            maxind = j;
        maxdist = output[maxind].second;
      }
      count++;
    }
  }
  return 0;
}
Ejemplo n.º 21
0
size_t integrate_times(
        Stepper stepper , System system , State &start_state ,
        TimeIterator start_time , TimeIterator end_time , Time dt ,
        Observer observer , stepper_tag
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
    typedef typename unit_value_type<Time>::type time_type;

    size_t steps = 0;
    Time current_dt = dt;
    while( true )
    {
        Time current_time = *start_time++;
        obs( start_state , current_time );
        if( start_time == end_time )
            break;
        while( less_with_sign( current_time , static_cast<time_type>(*start_time) , current_dt ) )
        {
            current_dt = min_abs( dt , *start_time - current_time );
            st.do_step( system , start_state , current_time , current_dt );
            current_time += current_dt;
            steps++;
        }
    }
    return steps;
}
	void CWhitePineWeevilModel::AddDailyResult(const StringVector& header, const StringVector& data)
	{
		enum TInputAllStage{ E_ID, E_YEAR, E_MONTH, E_DAY, E_DD, E_EGG, E_EGG_CUMUL, E_L1, E_CUMUL_L1, E_L2, E_CUMUL_L2, E_L3, E_CUMUL_L3, E_L4, E_CUMUL_L4, E_PUPA, E_CUMUL_PUPA, E_ADULT, E_CUMUL_ADULT, NB_INPUTS_STAGE };
		enum TInputDD{ P_YEAR, P_MONTH, P_DAY, P_DD, NB_INPUTS_DD };

		

		if (header.size() == NB_INPUTS_STAGE)
		{
			CTRef TRef(ToInt(data[E_YEAR]), ToSizeT(data[E_MONTH]) - 1, ToSizeT(data[E_DAY]) - 1);
			std::vector<double> obs(NB_STAGES,-999);

			for (size_t i = 0; i < 7 && E_EGG_CUMUL + 2 * i<data.size(); i++)
				obs[i] = !data[E_EGG_CUMUL + 2 * i].empty()?ToDouble(data[E_EGG_CUMUL + 2 * i]):-999;

			m_SAResult.push_back(CSAResult(TRef, obs));
		}
		/*else if (header.size() == NB_INPUTS_DD)
		{
		//CTRef TRef(ToInt(data[P_YEAR]), ToSizeT(data[P_MONTH]) - 1, ToSizeT(data[P_DAY]) - 1);
			std::vector<double> obs(2);

			obs[PUP_NB_DAYS] = ToDouble(data[P_NB_DAYS]);
			obs[PUP_N] = ToDouble(data[P_N]);

			m_SAResult.push_back(CSAResult(TRef, obs));
		}*/
	}
Ejemplo n.º 23
0
	double crudeMC(crudeMCArgs& args)
	{
		std::size_t n = args.n;
		if(n <= 0)
		{
			throw std::runtime_error("Input n must be positive");
		}
		
		const context& contextObj = args.contextObj;
		boost::detail::depth_first_visit_restricted_impl_helper<context::internalGraph>::stackType stack;

		std::vector<int> components;
		std::vector<int> interestComponents;
		const std::vector<int> interestVertices = contextObj.getInterestVertices();

		std::vector<boost::default_color_type> colorMap;
		int countDisconnected = 0;

		for(std::size_t i = 0; i < n; i++)
		{
			NetworkReliabilityObs obs(contextObj, args.randomSource);
			if(!isSingleComponent(contextObj.getGraph(), obs.getState(), components, stack, colorMap, contextObj.getInterestVertices()))
			{
				countDisconnected++;
			}			
		}
		return (float)countDisconnected / (float)n;
	}
Ejemplo n.º 24
0
    void 
    covafillJAGS::evaluate (double *value, vector<double const *> const &args,
		       vector<vector<unsigned int> > const &dims) const
    {
   
      // Create X
      unsigned int nrowX = dims[0][0];
      unsigned int ncolX = dims[0].size() == 2 ? dims[0][1] : 1;
      cMatrix X(nrowX,ncolX);
      unsigned int indx;
      indx = 0;
      // JAGS uses column-major
      for (unsigned int j = 0; j < ncolX; ++j) {
	for (unsigned int i = 0; i < nrowX; ++i) {
	  X(i,j) = args[0][indx++];
	}
      }
      
	// Create coordinates
	unsigned int nrowC = dims[1][0];
	unsigned int ncolC = dims[1].size() == 2 ? dims[1][1] : 1;
	cMatrix coord(nrowC,ncolC);
	indx = 0;
	// JAGS uses column-major
	for (unsigned int j = 0; j < ncolC; ++j) {
	  for (unsigned int i = 0; i < nrowC; ++i) {
	    coord(i,j) = args[1][indx++];
	  }
	}
  

      // Create obs
      unsigned int lengthO = dims[2][0];
      cVector obs(lengthO);
      for(unsigned int i = 0; i < lengthO; ++i){
	obs[i] = args[2][i];
      }

      // Create h
      unsigned int lengthH = dims[3][0];
      cVector h(ncolC);
      for(unsigned int i = 0; i < ncolC; ++i){
	if(lengthH == 1){
	  h[i] = args[3][0];
	}else{
	  h[i] = args[3][i];
	}
      }

      // Create p
      double p = args[4][0];

      // Create covarfill
      covafill<double> cf(coord,obs,h,p);

      // Calculate
      for(unsigned int i = 0; i < nrowX; ++i)
	value[i] = cf((cVector)X.row(i))(0);      
    }
Ejemplo n.º 25
0
TEST(DetectAll, detection) {
	// DetectAll should detect all candidates
	DetectAll obs("Wait", "You forgot your lunchbox");
	Candidate c;
	obs.process(&c);
	EXPECT_FALSE(c.isActive());
	EXPECT_TRUE(c.hasProperty("Wait"));
}
Ejemplo n.º 26
0
TEST(SmallObserverSphere, limitStep) {
	SmallObserverSphere obs(Vector3d(0, 0, 0), 1);
	Candidate c;
	c.setNextStep(10);
	c.current.setPosition(Vector3d(0, 0, 2));
	obs.process(&c);
	EXPECT_DOUBLE_EQ(c.getNextStep(), 1);
}
Ejemplo n.º 27
0
int ObservationInfo::processArgs (const char *arg)
{
	int obs_id;
	obs_id = atoi (arg);
	rts2db::Observation obs (obs_id);
	obsset->push_back (obs);
	return 0;
}
Ejemplo n.º 28
0
int main(int argc, char** argv) {

    pMyObservable d(new DataRepository);
    myObserver obs(d,"count_to_10_data");
    d->run();

    return 0;
}
Ejemplo n.º 29
0
List viterbi(const arma::mat& transition, NumericVector emissionArray,
  const arma::vec& init, IntegerVector obsArray) {

  IntegerVector eDims = emissionArray.attr("dim"); //m,p,r
  IntegerVector oDims = obsArray.attr("dim"); //k,n,r

  arma::cube emission(emissionArray.begin(), eDims[0], eDims[1], eDims[2], false, true);
  arma::icube obs(obsArray.begin(), oDims[0], oDims[1], oDims[2], false, true);

  arma::umat q(obs.n_slices, obs.n_cols);
  arma::vec logp(obs.n_slices);

  arma::mat delta(emission.n_rows, obs.n_cols);
  arma::umat phi(emission.n_rows, obs.n_cols);

  for (unsigned int k = 0; k < obs.n_slices; k++) {

    delta.col(0) = init;
    for (unsigned int r = 0; r < emission.n_slices; r++) {
      delta.col(0) += emission.slice(r).col(obs(r, 0, k));
    }

    phi.col(0).zeros();

    for (unsigned int t = 1; t < obs.n_cols; t++) {
      for (unsigned int j = 0; j < emission.n_rows; j++) {
        (delta.col(t - 1) + transition.col(j)).max(phi(j, t));
        delta(j, t) = delta(phi(j, t), t - 1) + transition(phi(j, t), j);
        for (unsigned int r = 0; r < emission.n_slices; r++) {
          delta(j, t) += emission(j, obs(r, t, k), r);
        }
      }
    }

    delta.col(obs.n_cols - 1).max(q(k, obs.n_cols - 1));

    for (int t = (obs.n_cols - 2); t >= 0; t--) {
      q(k, t) = phi(q(k, t + 1), t + 1);
    }
    logp(k) = delta.col(obs.n_cols - 1).max();
  }

  return List::create(Named("q") = wrap(q), Named("logp") = wrap(logp));
}
Ejemplo n.º 30
0
nsAppShellService::nsAppShellService() : 
  mXPCOMShuttingDown(PR_FALSE),
  mModalWindowCount(0),
  mApplicationProvidedHiddenWindow(PR_FALSE)
{
  nsCOMPtr<nsIObserverService> obs
    (do_GetService("@mozilla.org/observer-service;1"));

  if (obs)
    obs->AddObserver(this, "xpcom-shutdown", PR_FALSE);
}