C++ SymbolTable::Find方法代码示例

//-------------------------------------------------------------------------
//Function procedure_statement_2 implements the rule
//procedure_statement_2: procedure_statement -> ID ( expression_list )
//-------------------------------------------------------------------------
Exp* procedure_statement(string* id, List<Exp*>* EL)
{  Sym* S=ST.Find(*id);
   if (!S) yyerror("Semantic error - ID cannot be found");
   if (S->IsProcedureSymbol())
       return UserSubprogram((SubprogramSymbol*)S,EL);
   else if (S->IsStandardProcedureSymbol() ) 
       return StandardProcedure((StandardProcedureSymbol*)S,EL);
   else yyerror("Semantic error - ID must be a procedure");
}

void fstprintpaths::printAllStringsHelper(StdVectorFst& fst, SymbolTable& st, int state, string& str, TropicalWeight cost, string& seqToSkip, ProjectionEnum printInputOrOutput) 
{
        if(fst.Final(state) != TropicalWeight::Zero())
        {
            cout << str << " cost " << (Times(cost,fst.Final(state))) << endl;
            str = "";
            return;
        }

        for(ArcIterator< StdVectorFst > iter(fst,state); !iter.Done(); iter.Next()) 
        {
            StdArc arc = iter.Value();

            string symbol = (printInputOrOutput) == fstprintpaths::PROJECT_INPUT ? st.Find( arc.ilabel ) : st.Find( arc.olabel );

            if( symbol.compare( seqToSkip ) != 0 ) {
                str += symbol; 
            }

            printAllStringsHelper(fst, st, arc.nextstate, str, Times(cost, arc.weight.Value()), seqToSkip, printInputOrOutput);
        }
}

void M2MFstAligner::_conditional_max( bool y_given_x ){
  /*
    Compute the conditional distribution, P(Y|X) using the WFST paradigm.
    This is bassed on the approach from Shu and Hetherington 2002.
    It is assumed that all WFSTs and operations use the Log semiring.

    Given: 
           FST1 = P(X,Y)
    Compute:
           FST2 = P(X) 
             := Map_inv(Det(RmEps(Proj_i(FST1))))
           FST3 = P(Y|X)
             := Compose(FST2,FST1)

    Proj_i:  project on input labels
    RmEps:   epsilon removal
    Det:     determinize
    Map_inv: invert weights

    Notes: An analogous process may be used to compute P(X|Y).  In this
      case one would project on OUTPUT labels - Proj_o, and reverse the
      composition order to Compose(FST1,FST2).

    Future work:
      What we are doing here in terms of *generating* the JOINT fst each
      time is really just a dumb hack.  We *should* encode the model in an
      FST and encode the individual lattices, rather than doing the hacky
      manual label encoding that we currently rely on.
  */

  //Joint distribution that we start with
  VectorFst<LogArc>* joint  = new VectorFst<LogArc>();
  SymbolTable* misyms = new SymbolTable("misyms");
  SymbolTable* mosyms = new SymbolTable("mosyms");
  joint->AddState();
  joint->AddState();
  joint->SetStart(0);
  joint->SetFinal(1,LogArc::Weight::One());
  map<LogArc::Label,LogWeight>::iterator it;
  for( it=prev_alignment_model.begin(); it != prev_alignment_model.end(); it++ ){
    string isym = isyms->Find((*it).first); 
    vector<string> io = tokenize_utf8_string( &isym, &s1s2_sep );
    LogArc arc( misyms->AddSymbol(io[0]), mosyms->AddSymbol(io[1]), (*it).second, 1 );
    joint->AddArc( 0, arc );
  }
  //VectorFst<LogArc>* joint  = new VectorFst<LogArc>();
  //Push<LogArc,REWEIGHT_TO_FINAL>(*_joint, joint, kPushWeights);
  //joint->SetFinal(1,LogWeight::One());
  joint->Write("m2mjoint.fst");
  //BEGIN COMPUTE MARGINAL P(X)  
  VectorFst<LogArc>* dmarg;
  if( y_given_x )
    dmarg = new VectorFst<LogArc>(ProjectFst<LogArc>(*joint, PROJECT_INPUT));
  else
    dmarg = new VectorFst<LogArc>(ProjectFst<LogArc>(*joint, PROJECT_OUTPUT));

  RmEpsilon(dmarg);
  VectorFst<LogArc>* marg = new VectorFst<LogArc>();
  Determinize(*dmarg, marg);
  ArcMap(marg, InvertWeightMapper<LogArc>());

  if( y_given_x )
    ArcSort(marg, OLabelCompare<LogArc>());
  else
    ArcSort(marg, ILabelCompare<LogArc>());
  //END COMPUTE MARGINAL P(X)
  marg->Write("marg.fst");

  //CONDITIONAL P(Y|X)
  VectorFst<LogArc>* cond = new VectorFst<LogArc>();
  if( y_given_x )
    Compose(*marg, *joint, cond);
  else
    Compose(*joint, *marg, cond);
  //cond now contains the conditional distribution P(Y|X)
  cond->Write("cond.fst");
  //Now update the model with the new values
  for( MutableArcIterator<VectorFst<LogArc> > aiter(cond, 0); !aiter.Done(); aiter.Next() ){
    LogArc arc = aiter.Value();
    string lab = misyms->Find(arc.ilabel)+"}"+mosyms->Find(arc.olabel);
    int   labi = isyms->Find(lab);
    alignment_model[labi]      = arc.weight;
    prev_alignment_model[labi] = LogWeight::Zero();
  }
  delete joint, marg, cond, dmarg;
  delete misyms, mosyms;
  return;
}

void
relabel(StdMutableFst * fst, StdMutableFst * out, string prefix,
        string eps, string skip, string s1s2_sep, string seq_sep)
{
    namespace s = fst::script;
    using fst::ostream;
    using fst::SymbolTable;

    ArcSort(fst, StdILabelCompare());
    const SymbolTable *oldsyms = fst->InputSymbols();

    // generate new input, output and states SymbolTables
    SymbolTable *ssyms = new SymbolTable("ssyms");
    SymbolTable *isyms = new SymbolTable("isyms");
    SymbolTable *osyms = new SymbolTable("osyms");

    out->AddState();
    ssyms->AddSymbol("s0");
    out->SetStart(0);

    out->AddState();
    ssyms->AddSymbol("s1");
    out->SetFinal(1, TropicalWeight::One());

    isyms->AddSymbol(eps);
    osyms->AddSymbol(eps);

    //Add separator, phi, start and end symbols
    isyms->AddSymbol(seq_sep);
    osyms->AddSymbol(seq_sep);
    isyms->AddSymbol("<phi>");
    osyms->AddSymbol("<phi>");
    int istart = isyms->AddSymbol("<s>");
    int iend = isyms->AddSymbol("</s>");
    int ostart = osyms->AddSymbol("<s>");
    int oend = osyms->AddSymbol("</s>");

    out->AddState();
    ssyms->AddSymbol("s2");
    out->AddArc(0, StdArc(istart, ostart, TropicalWeight::One(), 2));

    for (StateIterator<StdFst> siter(*fst); !siter.Done(); siter.Next()) {
        StateId state_id = siter.Value();

        int64 newstate;
        if (state_id == fst->Start()) {
            newstate = 2;
        }
        else {
            newstate = ssyms->Find(convertInt(state_id));
            if (newstate == -1) {
                out->AddState();
                ssyms->AddSymbol(convertInt(state_id));
                newstate = ssyms->Find(convertInt(state_id));
            }
        }

        TropicalWeight weight = fst->Final(state_id);

        if (weight != TropicalWeight::Zero()) {
            // this is a final state
            StdArc a = StdArc(iend, oend, weight, 1);
            out->AddArc(newstate, a);
            out->SetFinal(newstate, TropicalWeight::Zero());
        }
        addarcs(state_id, newstate, oldsyms, isyms, osyms, ssyms, eps,
                s1s2_sep, fst, out);
    }


    out->SetInputSymbols(isyms);
    out->SetOutputSymbols(osyms);

    cout << "Writing text model to disk..." << endl;
    //Save syms tables
    isyms->WriteText(prefix + ".input.syms");
    osyms->WriteText(prefix + ".output.syms");

    string dest = prefix + ".fst.txt";
    fst::ofstream ostrm(dest.c_str());
    ostrm.precision(9);
    s::FstClass fstc(*out);
    s::PrintFst(fstc, ostrm, dest, isyms, osyms, NULL, acceptor, show_weight_one);
    ostrm.flush();
}

int main(int argc, char* argv[]) {

	StdVectorFst fst;

	SymbolTable* isyms;
	SymbolTable* osyms;

	{
		isyms = new SymbolTable("isyms.txt");
		osyms = new SymbolTable("osyms.txt");

		isyms->AddSymbol("a");
		isyms->AddSymbol("b");
		isyms->AddSymbol("c");
		isyms->Write("isyms.txt");

		osyms->AddSymbol("x");
		osyms->AddSymbol("y");
		osyms->AddSymbol("z");
		osyms->Write("osyms.txt");
	}

	{
		fst.SetInputSymbols(isyms);
		fst.SetOutputSymbols(osyms);

		// Adds state 0 to the initially empty FST and make it the start state.
		fst.AddState(); // 1st state will be state 0 (returned by AddState)
		fst.SetStart(0); // arg is state ID

		// Adds two arcs exiting state 0.
		// Arc constructor args: ilabel, olabel, weight, dest state ID.
		fst.AddArc(0, StdArc(isyms->Find("a"), osyms->Find("x"), 0.5, 1)); // 1st arg is src state ID
		fst.AddArc(0, StdArc(isyms->Find("b"), osyms->Find("y"), 1.5, 1));

		// Adds state 1 and its arc.
		fst.AddState();
		fst.AddArc(1, StdArc(isyms->Find("c"), osyms->Find("z"), 2.5, 2));

		// Adds state 2 and set its final weight.
		fst.AddState();
		fst.SetFinal(2, 3.5); // 1st arg is state ID, 2nd arg weight

		fst.Write("example.fst");
	}

	StdVectorFst search_fst;
	{
		search_fst.SetInputSymbols(isyms);
		search_fst.SetOutputSymbols(osyms);

		search_fst.AddState(); // 1st state will be state 0 (returned by AddState)
		search_fst.SetStart(0); // arg is state ID

		// Adds two arcs exiting state 0.
		// Arc constructor args: ilabel, olabel, weight, dest state ID.
		search_fst.AddArc(0, StdArc(isyms->Find("a"), osyms->Find("x"), 0.5, 1)); // 1st arg is src state ID

		// Adds state 1 and its arc.
		search_fst.AddState();
		search_fst.AddArc(1, StdArc(isyms->Find("c"), osyms->Find("z"), 2.5, 2));

		// Adds state 2 and set its final weight.
		search_fst.AddState();
		search_fst.SetFinal(2, 3.5); // 1st arg is state ID, 2nd arg weight
	}

	{
		for (StateIterator<StdVectorFst> siter(fst); not siter.Done(); siter.Next()) {
			StdIntersectFst::StateId s = siter.Value();
			std::cout << "state=" << s << ":";
			for (ArcIterator<StdVectorFst> aiter(fst, s); not aiter.Done(); aiter.Next()) {
				const StdArc& arc = aiter.Value();
				std::cout << arc.ilabel << "/" << arc.olabel << "->" << arc.nextstate << ",";
			}
			std::cout << std::endl;
		}
	}

	{
		Matcher<StdVectorFst> matcher(fst, MATCH_INPUT);
		matcher.SetState(0);
		StdArc::Label find_label = 1;
		if (matcher.Find(find_label)) {
			for (; not matcher.Done(); matcher.Next()) {
				const StdArc& arc = matcher.Value();
				std::cout << "found=" 
					<< arc.ilabel << "/" << arc.olabel << "->" << arc.nextstate << std::endl;
			}
		}
	}


//	 intersect contains strings in both A and B
	{
		ArcSort(&fst, StdOLabelCompare());
		ArcSort(&search_fst, StdILabelCompare());
	
		/*
		ComposeFilter compose_filter;
//.........这里部分代码省略.........