Example #1
0
Chain ModelGetter::GetModel()
{
  const int MAX_LEN = 1024 ;
  char cur_line[1024] ;
  
  Chain chain ;
  while (!infile_.eof())
  {
    double model[6] ;
    infile_.getline(cur_line, MAX_LEN) ;
    int num_read = sscanf(cur_line, "%lf %lf %lf %lf %lf %lf", &model[0], &model[1], &model[2], &model[3], &model[4], &model[5]) ;
    if (num_read < 6)
      break ;
    
    // Now add the data to the chain
    Joint J(Joint::RotZ) ;
    Vector rot_axis(model[3], model[4], model[5]) ;           // KDL doesn't need vector to be normalized. It even behaves nicely with vector=[0 0 0]
    double rot_ang = rot_axis.Norm() ;
    Rotation R(Rotation::Rot(rot_axis, rot_ang)) ;
    Vector trans(model[0], model[1], model[2]) ;
    chain.addSegment(Segment(J, Frame(R, trans))) ;
  }
  
  return chain ;
}
Example #2
0
/** get all chains from the matching */
const RamAutoIndex::ChainOrderMap RamAutoIndex::getChainsFromMatching(const RamMaxMatching::Matchings& match, const SearchSet& nodes) {
    ASSERT(nodes.size() > 0);

    // Get all unmatched nodes from A
    const SearchSet& umKeys = getUnmatchedKeys(match, nodes);

    // Case: if no unmatched nodes then we have an anti-chain
    if (umKeys.size() == 0){ 
        for (SearchSet::const_iterator nit = nodes.begin(); nit != nodes.end(); ++nit) {
            std::set<SearchColumns> a;
            a.insert(*nit);
            chainToOrder.push_back(a);
            return chainToOrder;
        }
    }

    ASSERT(umKeys.size() > 0);

    // A worklist of used nodes
    SearchSet usedKeys;

    // Case: nodes < umKeys or if nodes == umKeys then anti chain - this is handled by this loop
    for (SearchSet::iterator it = umKeys.begin(); it != umKeys.end(); ++it) {
        Chain c = getChain(*it, match);
        ASSERT(c.size() > 0);
        chainToOrder.push_back(c);
    }

    ASSERT(chainToOrder.size() > 0);

    return chainToOrder;
}
void SolverTest::FkPosAndIkPosLocal(Chain& chain,ChainFkSolverPos& fksolverpos, ChainIkSolverPos& iksolverpos)
{
    JntArray q(chain.getNrOfJoints());
    for(unsigned int i=0; i<chain.getNrOfJoints(); i++)
    {
        random(q(i));
    }
    JntArray q_init(chain.getNrOfJoints());
    double tmp;
    for(unsigned int i=0; i<chain.getNrOfJoints(); i++)
    {
        random(tmp);
        q_init(i)=q(i)+0.1*tmp;
    }
    JntArray q_solved(q);

    Frame F1,F2;

    CPPUNIT_ASSERT(0==fksolverpos.JntToCart(q,F1));
    CPPUNIT_ASSERT(0 <= iksolverpos.CartToJnt(q_init,F1,q_solved));
    CPPUNIT_ASSERT(0==fksolverpos.JntToCart(q_solved,F2));

    CPPUNIT_ASSERT_EQUAL(F1,F2);
    //CPPUNIT_ASSERT_EQUAL(q,q_solved);

}
void SolverTest::FkPosAndJacLocal(Chain& chain,ChainFkSolverPos& fksolverpos,ChainJntToJacSolver& jacsolver)
{
    double deltaq = 1E-4;

    Frame F1,F2;

    JntArray q(chain.getNrOfJoints());
    Jacobian jac(chain.getNrOfJoints());

    for(unsigned int i=0; i<chain.getNrOfJoints(); i++)
    {
        random(q(i));
    }

    jacsolver.JntToJac(q,jac);

    for (unsigned int i=0; i< q.rows() ; i++)
    {
        // test the derivative of J towards qi
        double oldqi = q(i);
        q(i) = oldqi+deltaq;
        CPPUNIT_ASSERT(0==fksolverpos.JntToCart(q,F2));
        q(i) = oldqi-deltaq;
        CPPUNIT_ASSERT(0==fksolverpos.JntToCart(q,F1));
        q(i) = oldqi;
        // check Jacobian :
        Twist Jcol1 = diff(F1,F2,2*deltaq);
        Twist Jcol2(Vector(jac(0,i),jac(1,i),jac(2,i)),
                    Vector(jac(3,i),jac(4,i),jac(5,i)));

        //CPPUNIT_ASSERT_EQUAL(true,Equal(Jcol1,Jcol2,epsJ));
        CPPUNIT_ASSERT_EQUAL(Jcol1,Jcol2);
    }
}
void SolverTest::FkVelAndIkVelLocal(Chain& chain, ChainFkSolverVel& fksolvervel, ChainIkSolverVel& iksolvervel)
{

    JntArray q(chain.getNrOfJoints());
    JntArray qdot(chain.getNrOfJoints());

    for(unsigned int i=0; i<chain.getNrOfJoints(); i++)
    {
        random(q(i));
        random(qdot(i));
    }
    JntArrayVel qvel(q,qdot);
    JntArray qdot_solved(chain.getNrOfJoints());

    FrameVel cart;

    CPPUNIT_ASSERT(0==fksolvervel.JntToCart(qvel,cart));

    int ret = iksolvervel.CartToJnt(qvel.q,cart.deriv(),qdot_solved);
    CPPUNIT_ASSERT(0<=ret);

    qvel.deriv()=qdot_solved;

    if(chain.getNrOfJoints()<=6)
        CPPUNIT_ASSERT(Equal(qvel.qdot,qdot_solved,1e-5));
    else
    {
        FrameVel cart_solved;
        CPPUNIT_ASSERT(0==fksolvervel.JntToCart(qvel,cart_solved));
        CPPUNIT_ASSERT(Equal(cart.deriv(),cart_solved.deriv(),1e-5));
    }
}
bool KDLColladaLibraryJointsExporter::doExport(vector <Chain>& kdlChains)
{
    if (kdlChains.empty())
    {
        LOG(DEBUG) << "KDL Chains array is empty, has nothing to export";
        return false;
    }


    LOG(WARNING) << "Taking first element from the KDL chain array";

    Chain kdlChain = kdlChains[0];
    openLibrary();

    unsigned int jointNr = kdlChain.getNrOfSegments();

    for (unsigned int i = 0; i < jointNr; i++)
    {
        Segment segment = kdlChain.getSegment(i);
        Joint kdlJoint = segment.getJoint();
        string uniqueId = defaultJointIdPrefix + toString(i);
        COLLADASW::Joint colladaJoint = makeColladaSWJoint(COLLADASW::LibraryJoints::mSW, kdlJoint, uniqueId);
        LOG(INFO) << "Joint id: " << colladaJoint.getJointId();
        LOG(INFO) << "Joint name: " << colladaJoint.getJointName();
        addJoint(colladaJoint);
        joints.push_back(colladaJoint);
    }

    closeLibrary();

    return true;
}
Example #7
0
		void score_res(ScoreBase * scoring, std::string filename, std::string score_type = "pairing") {
			Chain chain;
			int i, j, l;

			chain_read_model(chain, filename);
			l = chain.size();
			//JN_JN_OUT << l << std::endl;
			for (i = 0; i < l; i++) {
				for (j = 0; j < l; j++) {
					if (i == j) JN_OUT << 0 << "\t";
					else {
						scoring->en_bp(chain[i], chain[j]);
						if (score_type == "pairing") JN_OUT << scoring->m_en_pairing << "\t";
						else if (score_type == "stacking") JN_OUT << scoring->m_en_stacking << "\t";
						else if (score_type == "wc") JN_OUT << scoring->m_en_wc << "\t";
						else if (score_type == "nwc") JN_OUT << scoring->m_en_nwc << "\t";
						else {
							LOG << "Illegal score type: " << score_type << std::endl;
							throw "error!";
						}
					}
				}
				JN_OUT << std::endl;
			}
		}
Example #8
0
File: 25.cpp Project: olgerda/eckel
int main ()
{
	Chain ch;
	ch.start.init();
	ch.chainBuilder (&ch.start, 5);
	ch.chainWalker (&ch.start);
}
Example #9
0
// Merges two chains
void Board::mergeChains(Chain *node, int otherID, Move m) {
    // Find the chain to merge into the first chain
    Chain *temp = nullptr;
    int tempIndex = searchChainsByID(temp, otherID);

    // Update the chain id array when merging
    for (int i = 0; i < temp->size; i++) {
        Move idChange = temp->squares[i];
        chainID[index(getX(idChange), getY(idChange))] = node->id;

        node->add(idChange);
    }

    // Remove the move played from the other list of liberties
    temp->removeLiberty(temp->findLiberty(m));
    // And then merge the two lists
    for (int i = 0; i < temp->liberties; i++) {
        // If the liberty is not a repeat
        if (node->findLiberty(temp->libertyList[i]) == -1)
            node->addLiberty(temp->libertyList[i]);
    }

    // Delete the chain "temp" now since it has been fully merged in
    delete temp;
    chainList.removeFast(tempIndex);
}
void TestPart2(){
	
	Chain<string> a, b;
	
	a.ReadChain(); // User provides input for Chain a.
	cout <<"A: "<< a <<endl;
	cout <<"A.size: "<< a.Size()<<endl;
	
	b.ReadChain(); // User provides input for Chain b. 
	cout <<"B: "<< b << endl;
	cout <<"B.size: "<< b.Size()<<endl;
	
	cout <<"A+B: "<<a + b << endl; // Concatenates the two Chains.
	Chain<string> d = a + b; 
	cout <<"D: "<< d << endl;
	cout <<"D.size: "<< d.Size()<<endl;

	cout <<"D+: "<< d + "hi_there" <<endl; // Adds an element to the end.
	cout <<"D+.size: "<< d.Size()<<endl;
	cout <<"A[2]: "<< a[2] << endl; 	// Should print the 3rd element.
							// Throw an exception (or even abort()) if is out of
							// range.
	b[1] = "b_string"; // Should change the 2nd element to “b_string”
	cout <<"B: "<< b << endl;
	b[0] = "a_string"; 
	cout <<"B: "<< b <<endl;
	cout <<"B.size: "<< b.Size()<<endl;

} // End of TestPart2
size_t Board::removeCapturedStones (StoneColor colorToCapture)
{
    LOG_FUNCTION(cout, "Board::removeCapturedStones");

    size_t captureCount = 0;

    // A set of points that we've already examined. This helps prevents some
    // bad recursion and keeps a chain from being "found" once for each stone
    // in the chain.
    //
    ConstPointSet alreadyVisited;

    for (size_t row = 0; row < m_points.size(); ++row)
    {
        for (size_t column = 0; column < m_points[row].size(); ++column)
        {
            const Point & thePoint = m_points.at(row).at(column);

            // If the point we are considering has already been visited,
            // then Chain's ctor will throw a PointVisitedAlreadyException
            // object. We can safely swallow that exception and move on
            // to the next point.
            //
            try
            {
                Chain currentChain {thePoint, *this, &alreadyVisited};

                gLogger.log(LogLevel::kMedium, cout, "Discovered chain"); // " : ", chain);

                // If the chain we are looking at is the color we should consider capturing and
                // the chain has no liberties, then capture it
                //
                if (currentChain.color() == colorToCapture && currentChain.libertyCount() == 0)
                {
                    captureCount += currentChain.size();

                    // For each point in the chain, remove the stone from the board
                    // at those coordniates
                    //
                    currentChain.forEachPoint([this](const Point & point)
                    {
                        LOG_BUSY_FUNCTION(cout, "Chain::removeCapturedStones::lambda_doStoneRemoval");
                        m_points[point.coordinates.row][point.coordinates.column].removeStone();
                    });
                }
            }
            catch (const Chain::PointVisitedAlreadyException & ex)
            {
                gLogger.log(LogLevel::kFirehose, cout, "Skipping ", thePoint);
            }
        }
    }

    // If we ended up only capturing one stone, the 'Ko' rule might affect
    // the next move, so remember that fact!
    //
    m_koState.first = (captureCount == 1);

    return captureCount;
}
Example #12
0
  void reset(){

    for (int i =0;i<chain.num();++i){
        chain.link(i).pos(0,2,offset);
        chain.link(i).rot() = Gen::rot(Biv::xz * PIOVERFOUR);
    }

  }
Example #13
0
int VerifyJacobian::ComputeMaxError(const std::string& model_file, const std::string& joint_params_file, const std::string& jacobians_file, double& max_error)
{
  int result ;
  
  result = model_getter_.OpenFile(model_file) ;
  if (result < 0)
    return -1 ;

  result = joint_params_getter_.OpenFile(joint_params_file) ;
  if (result < 0)
    return -1 ;

  result = jacobians_getter_.OpenFile(jacobians_file) ;
  if (result < 0)
    return -1 ;
  
  Chain chain = model_getter_.GetModel() ;

  const unsigned int J = chain.getNrOfJoints() ;
  JntArray joint_array(J) ;
  result = joint_params_getter_.GetNextJointArray(joint_array) ;
  if (result < 0)
    return -1 ;
  
  LinkParamJacobian jac_actual ;
  jac_actual.twists_.resize(J) ;
  result = jacobians_getter_.GetNextJacobian(jac_actual) ;

  // Compute the jacobian using KDL functions
  
  LinkParamJacobian jac_computed ;
  jac_computed.twists_.resize(J) ;
  
  LinkParamJacobianSolver jac_solver ;
  jac_solver.JointsToCartesian(chain, joint_array, jac_computed) ;
  
  max_error = 0.0 ;
  for (unsigned int i=0; i < jac_computed.twists_.size(); i++)
  {
    for (unsigned int j=0; j<3; j++)
    {
      for (unsigned int k=0; k<3; k++)
      {
        double cur_error ;
        cur_error = fabs( jac_computed.twists_[i].trans_[j].vel(k) - jac_actual.twists_[i].trans_[j].vel(k) ) ;
        if (cur_error > max_error)
          max_error = cur_error ;
        
        cur_error = fabs( jac_computed.twists_[i].rot_[j].vel(k) - jac_actual.twists_[i].rot_[j].vel(k) ) ;
        if (cur_error > max_error)
          max_error = cur_error ;
      }
    }
  }    
  
  return 0 ;
}
bool Tree::addChain(const Chain& chain, const std::string& hook_name) {
    string parent_name = hook_name;
    for (unsigned int i = 0; i < chain.getNrOfSegments(); i++) {
        if (this->addSegment(chain.getSegment(i), parent_name))
          parent_name = chain.getSegment(i).getName();
        else
            return false;
    }
    return true;
}
Example #15
0
void
Module::set ( Log_Entry &e )
{
    for ( int i = 0; i < e.size(); ++i )
    {
        const char *s, *v;

        e.get( i, &s, &v );

        if ( ! strcmp( s, ":chain" ) )
        {
            /* This trickiness is because we may need to know the name of
               our chain before we actually get added to it. */
            int i;
            sscanf( v, "%X", &i );
            Chain *t = (Chain*)Loggable::find( i );

            assert( t );

            chain( t );
        }
    }

    for ( int i = 0; i < e.size(); ++i )
    {
        const char *s, *v;

        e.get( i, &s, &v );

/*         if ( ! strcmp( s, ":name" ) ) */
/*             label( v ); */
        if ( ! strcmp( s, ":parameter_values" ) )
        {
            set_parameters( v );
        }
        else if ( ! ( strcmp( s, ":is_default" ) ) )
        {
            is_default( atoi( v ) );
        }
        else if ( ! ( strcmp( s, ":active" ) ) )
        {
            bypass( ! atoi( v ) );
        }
        else if ( ! strcmp( s, ":chain" ) )
        {
            int i;
            sscanf( v, "%X", &i );
            Chain *t = (Chain*)Loggable::find( i );

            assert( t );

            t->add( this );
        }
    }
}
// method calculates error between two chains, used in finduniquecombination method
//
// Chain upper: the first chain, uses i values
// Chain lower: the second chain, uses i-1 values
//
// returns: double of error amount
double SearchStrategy::assignmentError(Chain upper, Chain lower)
{
	double AiM1 = (lower.first()).getCAIM()[0];
	double BiM1 = (lower.first()).getCBIM()[0];
	double Ai = (upper.last()).getCAI()[0];
	double Bi = (upper.last()).getCBI()[0];

	double squashedError = abs((AiM1 - Ai) / Ai) + abs((BiM1 - Bi)/ Bi);

	return squashedError;
}
Example #17
0
File: chain.hpp Project: bnels/ctl
	Chain operator+( const Chain & b) const {
	   Chain result( size()+b.size());
	   auto leftover = ctl::detail::chain_add( rbegin(), rend(), 
	   			            b.rbegin(), b.rend(),
	   			            result.rbegin(),
	   			            std::bind(Less(), 
						      std::placeholders::_2, 
						      std::placeholders::_1),
	   			            Chain::coeff_tag());
	   result._chain.erase( leftover, result.rend());
	   return result;
	}
Example #18
0
int FastaReader::getIndex(Chain &_ch, std::string _posId, std::string _key){

  Position &pos = _ch.getPosition(_posId);
  
  // get fasta seq.
  string fasta = getSequence(_key);

#ifdef __BOOST__
  int posIndex = _ch.getPositionIndex(&pos);

  // Find index of first non '-' character
  boost::regex re("^-*(!-)");

  boost::cmatch matches;
  if (!boost::regex_match(fasta.c_str(),matches,re)) {
    cerr << "ERROR 9234 with boost match"<<endl;
    exit(9234);
  }

  //cout << "Match: "<<matches.position()<< " fasta AA is: "<<fasta[matches.position()]<<endl;

  // Go from matches[0].first to posIndex OR end of string
  int index = matches.position();
  int posIndex_counter = posIndex;
  while (index != fasta.size()){
    
    if (fasta[index] != '-'){
      posIndex_counter--;
    }

    // Check if we are here!
    if (posIndex_counter == 0){
      break;
    }
    index++;
  }

  if (posIndex_counter == 0){

    // Check it the position and this index have the same AA, if not then probably there is an issue.
    if (MslTools::getOneLetterCode(pos.getResidueName()) != MslTools::stringf("%c",fasta[index])){
      cerr << "ERROR 9255 Position AA is: "<<MslTools::getOneLetterCode(pos.getResidueName())<< " and Fasta AA is: "<<fasta[index]<<endl;
      exit(9255);
    } 

    // Return the index
    return index;
  }
#endif

  return -1;
}
int main(int argc, const char* argv[]) {
	stringstream strm;
	strm << "line (5.12,0.11,-2.5),(10,-7.5,2.4)";
	string str = strm.str();
	PtrStrVec str_vec = string_splitter(str);	
	Chain* ch = new Chain(str_vec);
	double* params = ch->solve();
	/*Solid* s = factory(5,RGB(0,0,0),params);
	delete s;*/
	delete [] params;
	delete ch;
	delete str_vec;
	return 0;
};
Example #20
0
bool Tree::addChain(const Chain& chain, const std::string& chain_name,
        const std::string& hook_name) {
    string parent_name = hook_name;
    for (unsigned int i = 0; i < chain.getNrOfSegments(); i++) {
        ostringstream segment_name;
        segment_name << chain_name << "Segment" << i;
        if (this->addSegment(chain.getSegment(i), segment_name.str(),
                parent_name))
            parent_name = segment_name.str();
        else
            return false;
    }
    return true;
}
Example #21
0
    std::string operator()(const std::vector<std::string> & argvec) {
        if (argvec.size() != 4) {
            return interp->RunCommand("help alias") + "\n(Please refer to the help documentation for proper invocation)";
        }


        // First get the alias name
        std::string cmd = argvec[1];
        std::vector<std::string> cmds;


        // Next get the arguments.
        Chain argSrc = argvec[2].c_str();
        std::vector<std::string> args;
        argSrc.SetDelimiters(",");
        while(argSrc.LinksLeft()) {
            args.push_back(argSrc.GetLink().c_str());
            argSrc++;
        } 
        
        

        Chain src = argvec[3].c_str();
        src.SetDelimiters(",");

        while(src.LinksLeft()) {
            cmds.push_back(src.GetLink().c_str());
            src++;
        }    
        interp->AddCommand(cmd, new SubCommand(cmds, args, interp));

        return std::string("Set new command: ") + cmd;
        
    }
Example #22
0
void ConstellationBoundaries::render()
{
    for (vector<Chain*>::iterator iter = chains.begin();
         iter != chains.end(); iter++)
    {
        Chain* chain = *iter;
        glBegin(GL_LINE_STRIP);
        for (Chain::iterator citer = chain->begin(); citer != chain->end();
             citer++)
        {
            glVertex(*citer);
        }
        glEnd();
    }
}
bool Tree::getChain(const std::string& chain_root, const std::string& chain_tip, Chain& chain)const
{
    // clear chain
    chain = Chain();

    // walk down from chain_root and chain_tip to the root of the tree
    vector<SegmentMap::key_type> parents_chain_root, parents_chain_tip;
    for (SegmentMap::const_iterator s=getSegment(chain_root); s!=segments.end(); s=s->second.parent){
        parents_chain_root.push_back(s->first);
        if (s->first == root_name) break;
    }
    if (parents_chain_root.empty() || parents_chain_root.back() != root_name) return false;
    for (SegmentMap::const_iterator s=getSegment(chain_tip); s!=segments.end(); s=s->second.parent){
        parents_chain_tip.push_back(s->first);
        if (s->first == root_name) break;
    }
    if (parents_chain_tip.empty() || parents_chain_tip.back()  != root_name) return false;

    // remove common part of segment lists
    SegmentMap::key_type last_segment = root_name;
    while (!parents_chain_root.empty() && !parents_chain_tip.empty() &&
           parents_chain_root.back() == parents_chain_tip.back()){
        last_segment = parents_chain_root.back();
        parents_chain_root.pop_back();
        parents_chain_tip.pop_back();
    }
    parents_chain_root.push_back(last_segment);


    // add the segments from the root to the common frame
    for (unsigned int s=0; s<parents_chain_root.size()-1; s++){
        Segment seg = getSegment(parents_chain_root[s])->second.segment;
        Frame f_tip = seg.pose(0.0).Inverse();
        Joint jnt = seg.getJoint();
        if (jnt.getType() == Joint::RotX || jnt.getType() == Joint::RotY || jnt.getType() == Joint::RotZ || jnt.getType() == Joint::RotAxis)
            jnt = Joint(jnt.getName(), f_tip*jnt.JointOrigin(), f_tip.M*jnt.JointAxis(), Joint::RotAxis);
        else if (jnt.getType() == Joint::TransX || jnt.getType() == Joint::TransY || jnt.getType() == Joint::TransZ || jnt.getType() == Joint::TransAxis)
            jnt = Joint(jnt.getName(),f_tip*jnt.JointOrigin(), f_tip.M*jnt.JointAxis(), Joint::TransAxis);
        chain.addSegment(Segment(getSegment(parents_chain_root[s+1])->second.segment.getName(),
                                 jnt, f_tip, getSegment(parents_chain_root[s+1])->second.segment.getInertia()));
    }

    // add the segments from the common frame to the tip frame
    for (int s=parents_chain_tip.size()-1; s>-1; s--){
        chain.addSegment(getSegment(parents_chain_tip[s])->second.segment);
    }
    return true;
}
ChainIkSolverPos_LMA_JL_Mimic::ChainIkSolverPos_LMA_JL_Mimic(const Chain& _chain,
                                                           const JntArray& _q_min,
                                                           const JntArray& _q_max,
                                                           ChainFkSolverPos& _fksolver,
                                                           ChainIkSolverPos_LMA& _iksolver,
                                                           unsigned int _maxiter,
                                                           double _eps,
                                                           bool _position_ik)
  : chain(_chain),
    q_min(_q_min),
    q_min_mimic(chain.getNrOfJoints()),
    q_max(_q_max),
    q_max_mimic(chain.getNrOfJoints()),
    q_temp(chain.getNrOfJoints()),
    fksolver(_fksolver),
    iksolver(_iksolver),
    delta_q(_chain.getNrOfJoints()),
    maxiter(_maxiter),
    eps(_eps),
    position_ik(_position_ik)
{
  mimic_joints.resize(chain.getNrOfJoints());
  for(std::size_t i=0; i < mimic_joints.size(); ++i)
  { 
    mimic_joints[i].reset(i);
  }
}
Chain FullMorphologyChainTransformer::ForwardTransform(Chain& chain) const
{
    int oldLength = chain.GetSize();
    if (oldLength == 0)
    {
        return chain;
    }
    // Create tokens
    const vector<wstring>& oldTokens = chain.GetTokens();
    vector<wstring> tokens(2 * oldLength - 1);
    for (size_t nodeIndex = 0; nodeIndex + 1 < oldTokens.size(); ++nodeIndex)
    {
        tokens[2 * nodeIndex + 1] = L"copy_" + oldTokens[nodeIndex];
        tokens[2 * nodeIndex] = std::move(oldTokens[nodeIndex]);
    }
    // Create labels
    const vector<wstring>& oldLabels = chain.GetLabels();
    vector<wstring> labels(2 * oldLength - 1);
    for (size_t nodeIndex = 0; nodeIndex + 1 < oldLabels.size(); ++nodeIndex)
    {
        const wstring& fullLabel = oldLabels[nodeIndex];
        if (fullLabel.size() > 0)
        {
            vector<wstring> splitted;
            splitted = Tools::Split(fullLabel, L"@");
            labels[2 * nodeIndex] = fullLabel;
            labels[2 * nodeIndex + 1] = L"POS_" + splitted[0];
        }
    }
    labels[labels.size() - 1] = oldLabels.back();
    // Create features
    const vector<vector<wstring> >& oldFeatures = chain.GetFeatures();
    vector<vector<wstring> > features(2 * oldLength - 1);
    for (size_t nodeIndex = 0; nodeIndex + 1 < oldLabels.size(); ++nodeIndex)
    {
        features[2 * nodeIndex] = oldFeatures[nodeIndex];
        features[2 * nodeIndex + 1] = std::move(oldFeatures[nodeIndex]);
    }
    features[features.size() - 1] = oldFeatures.back();
    // Return chain
    Chain transformed(
        std::move(tokens)
        , std::move(features)
        , std::move(labels)
        , vector<vector<wstring> >());
    return transformed;
}
 ChainIkSolverPos_NR::ChainIkSolverPos_NR(const Chain& _chain,ChainFkSolverPos& _fksolver,ChainIkSolverVel& _iksolver,
                                          unsigned int _maxiter, double _eps):
     chain(_chain),nj (chain.getNrOfJoints()),
     iksolver(_iksolver),fksolver(_fksolver),
     delta_q(_chain.getNrOfJoints()),
     maxiter(_maxiter),eps(_eps)
 {
 }
typename CollapsedAKQReducedCubSComplexSupplier<Traits>::Chain
CollapsedAKQReducedCubSComplexSupplier<Traits>::GetBoundary(const Id& cellId)
{
    OutputSComplex* outputComplex = _algorithm->getStrategy()->getOutputComplex();
    Cell cell = (*outputComplex)[cellId];
    Chain boundary;
    BdCells bdCells = outputComplex->iterators().bdCells(cell);
    typename BdCells::iterator it = bdCells.begin();
    typename BdCells::iterator itEnd = bdCells.end();
    for ( ; it != itEnd; ++it)
    {
        int ci = outputComplex->coincidenceIndex(cell, *it);
        assert(ci != 0);
        boundary.push_back(std::pair<Id, int>(it->getId(), ci));
    }
    return boundary;
}
Example #28
0
int main(int argc, const char *argv[])
{
    Chain<int> X;
    int numbers[] = {
        216, 521, 425, 116, 91, 515, 124, 34, 96, 24};

    for (int i = 0; i < 10; i++)
        X.Insert(0, numbers[i]);
    std::cout<<"X is "<<X<<std::endl;
    X.BinSort(9, GeWei);
    std::cout<<"after BinSort, X is "<<X<<std::endl;
    X.BinSort(9, ShiWei);
    std::cout<<"after BinSort, X is "<<X<<std::endl;
    X.BinSort(9, BaiWei);
    std::cout<<"after BinSort, X is "<<X<<std::endl;
    return 0;
}
Example #29
0
// 1/4/2016
// 'demographicPara' is a 1x6 matrix.
long double MaxPosterior::computeLogJointDensity_MPI_overSubLoci(Eigen::MatrixXd demographicPara, IM im, popTree* poptree, Chain coldCh, unsigned int nProcs, unsigned int crr_procID)
{
  // std::cout <<"In computeLogJointDensity_MPI_overSubLoci()\n";

  poptree->replacePara(demographicPara);

  coldCh.compute_partialJointPosteriorDensity_overSubLoci(poptree, im, crr_procID, nProcs);
  std::vector<long double> logExpectationOfEachCoalProb = coldCh.get_logExpectationOfCoalProb();
  unsigned int numSubLoci = coldCh.getNumSubLoci();

  // std::cout <<"numSubLoci ="<<numSubLoci <<"\n";

  long double posterior = 1;
  if(numSubLoci != logExpectationOfEachCoalProb.size())
    {
      std::cout << "** Error In MaxPosterior::computeJointDensity_MPI_overSubSample() **\n";
      std::cout << "numSubLoci = " << numSubLoci 
		<< " expectationOfEachCoalProb.size() = " << logExpectationOfEachCoalProb.size() <<"\n\n";
    }
  long double local_logPosterior_subLoci =0;
  long double global_logPosterior = 0;
  for(unsigned int lc=0; lc< numSubLoci; lc++)
    {
      local_logPosterior_subLoci += logExpectationOfEachCoalProb.at(lc);
    }
  
  MPI::COMM_WORLD.Barrier();
  MPI::COMM_WORLD.Allreduce(&local_logPosterior_subLoci, &global_logPosterior, 1, MPI_LONG_DOUBLE, MPI_SUM);
  MPI::COMM_WORLD.Barrier();
  
  long double logPosterior = 0;
  if(crr_procID ==0)
    {	
      Eigen::Vector3d paraMax = im.get_paraMax();
      double priorPopTree = poptree->computeJointPrior(paraMax);
      //posterior = exp(global_logPosterior+log(priorPopTree));
      logPosterior = global_logPosterior; //  +log(priorPopTree);
      // std::cout <<"log(priorPopTree) = " << log(priorPopTree) <<"\n";
    }
  
 
  
  // std::cout << "crr_procID=" << crr_procID << " logPosterior = " << logPosterior <<"\n";    
  return logPosterior;
}
/**
 * Runs the epoch simulation for the period and updates the variables.
 *
 * Similar to: siena07models.cpp mlPeriod()
 *
 * @param m Period.
 */
void MetropolisHastingsSimulation::simulatePeriod(const int m) {
	MLSimulation* pSim = new MLSimulation(lpData, lpModel);

	// Update simulations
	pSim->simpleRates(lpModel->simpleRates());
	pSim->currentPermutationLength(lpModel->currentPermutationLength(m));

	pSim->missingNetworkProbability(
			static_cast<const Model*>(lpModel)->missingNetworkProbability(m));

	pSim->missingBehaviorProbability(
			static_cast<const Model*>(lpModel)->missingBehaviorProbability(m));

	LOGS(Priority::VERBOSE)<<"\nSimple rates: "<<pSim->simpleRates()
	<<"\nCurrent permutation length: "<<pSim->currentPermutationLength()
	<<"\nMissing network probability: "<<pSim->missingNetworkProbability()
	<<"\nMissing behavior probability: "<<pSim->missingBehaviorProbability();

	pSim->pChain(lpModel->rChainStore(m).back()->copyChain());
	lpModel->needScores(false);
	lpModel->needDerivatives(false);
	lpModel->numberMLSteps(lNRunMH[m]);

	LOGS(Priority::VERBOSE)<<"\nNum steps: "<<lpModel->numberMLSteps();

	pSim->runEpoch(m);
	// Run through current state of chain and calculate scores and derivatives.
	lpModel->needScores(true); // !onlyLoglik (bayes)
	lpModel->needDerivatives(lNeedsDerivative);

	pSim->updateProbabilities(pSim->pChain(), pSim->pChain()->pFirst()->pNext(),
			pSim->pChain()->pLast()->pPrevious());
	// Store chain on Model.
	Chain* pChain = pSim->pChain();
	pChain->createInitialStateDifferences();
	pSim->createEndStateDifferences();
	lpModel->chainStore(*pChain, m);
	lpModel->currentPermutationLength(m, pSim->currentPermutationLength());

	// Add up period results.
	addSingleScores(lScores[0], m, *pSim);
	addSingleDerivatives(lDerivative[0], m, *pSim);

	LOGS(Priority::DEBUG)<<"Scores: "<<lScores[0].transpose();
}