DeterminizerStar< F > Class Template Reference

#include <determinize-star-inl.h>

Collaboration diagram for DeterminizerStar< F >:

Classes
struct	Element
class	EpsilonClosure
class	PairComparator
class	SubsetEqual
class	SubsetEqualStates
class	SubsetKey
struct	TempArc

Public Member Functions
void	Output (MutableFst< GallicArc< Arc > > *ofst, bool destroy=true)
void	Output (MutableFst< Arc > *ofst, bool destroy=true)
	DeterminizerStar (const Fst< Arc > &ifst, float delta=kDelta, int max_states=-1, bool allow_partial=false)
void	Determinize (bool *debug_ptr)
bool	IsPartial ()
void	FreeMostMemory ()
	~DeterminizerStar ()

Private Types
typedef F::Arc	Arc
typedef Arc::Label	Label
typedef Arc::Weight	Weight
typedef Arc::StateId	InputStateId
typedef Arc::StateId	OutputStateId
typedef Arc::Label	StringId
typedef StringRepository< Label, StringId >	StringRepositoryType
typedef unordered_map< const std::vector< Element > *, OutputStateId, SubsetKey, SubsetEqual >	SubsetHash

Private Member Functions
void	ProcessFinal (const std::vector< Element > &closed_subset, OutputStateId state)
void	ProcessTransition (OutputStateId state, Label ilabel, std::vector< Element > *subset)
void	ProcessTransitions (const std::vector< Element > &closed_subset, OutputStateId state)
OutputStateId	SubsetToStateId (const std::vector< Element > &subset)
void	ProcessSubset (const std::pair< std::vector< Element > *, OutputStateId > &pair)
void	Debug ()
	KALDI_DISALLOW_COPY_AND_ASSIGN (DeterminizerStar)

Private Attributes
std::deque< std::pair< std::vector< Element > *, OutputStateId > >	Q_
std::vector< std::vector< TempArc > >	output_arcs_
const Fst< Arc > *	ifst_
float	delta_
int	max_states_
bool	determinized_
bool	allow_partial_
bool	is_partial_
SubsetKey	hasher_
SubsetEqual	equal_
SubsetHash	hash_
StringRepository< Label, StringId >	repository_
EpsilonClosure	epsilon_closure_

Detailed Description

template<class F>
class fst::DeterminizerStar< F >

Definition at line 159 of file determinize-star-inl.h.

Member Typedef Documentation

Arc

typedef F::Arc Arc

private

Definition at line 160 of file determinize-star-inl.h.

InputStateId

typedef Arc::StateId InputStateId

private

Definition at line 247 of file determinize-star-inl.h.

Label

typedef Arc::Label Label

private

Definition at line 245 of file determinize-star-inl.h.

OutputStateId

typedef Arc::StateId OutputStateId

private

Definition at line 248 of file determinize-star-inl.h.

StringId

typedef Arc::Label StringId

private

Definition at line 249 of file determinize-star-inl.h.

StringRepositoryType

typedef StringRepository<Label, StringId> StringRepositoryType

private

Definition at line 250 of file determinize-star-inl.h.

SubsetHash

typedef unordered_map<const std::vector<Element>*, OutputStateId, SubsetKey, SubsetEqual> SubsetHash

private

Definition at line 344 of file determinize-star-inl.h.

Weight

typedef Arc::Weight Weight

private

Definition at line 246 of file determinize-star-inl.h.

Constructor & Destructor Documentation

DeterminizerStar()

DeterminizerStar ( const Fst< Arc > &  ifst, float  delta = kDelta, int  max_states = -1, bool  allow_partial = false  )

inline

Definition at line 176 of file determinize-star-inl.h.

                                                                   :
      ifst_(ifst.Copy()), delta_(delta), max_states_(max_states),
      determinized_(false), allow_partial_(allow_partial),
      is_partial_(false), equal_(delta),
      hash_(ifst.Properties(kExpanded, false) ?
              down_cast<const ExpandedFst<Arc>*,
              const Fst<Arc> >(&ifst)->NumStates()/2 + 3 : 20,
            hasher_, equal_),
      epsilon_closure_(ifst_, max_states, &repository_, delta) { }

~DeterminizerStar()

~DeterminizerStar ( )

inline

Definition at line 241 of file determinize-star-inl.h.

                      {
    FreeMostMemory();
  }

Member Function Documentation

Debug()

void Debug ( )

private

Definition at line 1068 of file determinize-star-inl.h.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, and kaldi::swap().

                                {
  // this function called if you send a signal
  // SIGUSR1 to the process (and it's caught by the handler in
  // fstdeterminizestar).  It prints out some traceback
  // info and exits.

  KALDI_WARN << "Debug function called (probably SIGUSR1 caught)";
  // free up memory from the hash as we need a little memory
  { SubsetHash hash_tmp; std::swap(hash_tmp, hash_); }

  if (output_arcs_.size() <= 2) {
    KALDI_ERR << "Nothing to trace back";
  }
  size_t max_state = output_arcs_.size() - 2;  // don't take the last
  // one as we might be halfway into constructing it.

  std::vector<OutputStateId> predecessor(max_state+1, kNoStateId);
  for (size_t i = 0; i < max_state; i++) {
    for (size_t j = 0; j < output_arcs_[i].size(); j++) {
      OutputStateId nextstate = output_arcs_[i][j].nextstate;
      // Always find an earlier-numbered predecessor; this
      // is always possible because of the way the algorithm
      // works.
      if (nextstate <= max_state && nextstate > i)
        predecessor[nextstate] = i;
    }
  }
  std::vector<std::pair<Label, StringId> > traceback;
  // 'traceback' is a pair of (ilabel, olabel-seq).
  OutputStateId cur_state = max_state;  // A recently constructed state.

  while (cur_state != 0 && cur_state != kNoStateId) {
    OutputStateId last_state = predecessor[cur_state];
    std::pair<Label, StringId> p;
    size_t i;
    for (i = 0; i < output_arcs_[last_state].size(); i++) {
      if (output_arcs_[last_state][i].nextstate == cur_state) {
        p.first = output_arcs_[last_state][i].ilabel;
        p.second = output_arcs_[last_state][i].ostring;
        traceback.push_back(p);
        break;
      }
    }
    KALDI_ASSERT(i != output_arcs_[last_state].size());  // Or fell off loop.
    cur_state = last_state;
  }
  if (cur_state == kNoStateId)
    KALDI_WARN << "Traceback did not reach start state "
    << "(possibly debug-code error)";

  std::stringstream ss;
  ss << "Traceback follows in format "
    << "ilabel (olabel olabel) ilabel (olabel) ... :";
  for (ssize_t i = traceback.size() - 1; i >= 0; i--) {
    ss << ' ' << traceback[i].first << " ( ";
    std::vector<Label> seq;
    repository_.SeqOfId(traceback[i].second, &seq);
    for (size_t j = 0; j < seq.size(); j++)
      ss << seq[j] << ' ';
    ss << ')';
  }
  KALDI_ERR << ss.str();
}

Determinize()

void Determinize ( bool *  debug_ptr )

inline

Definition at line 187 of file determinize-star-inl.h.

References KALDI_ERR, KALDI_WARN, DeterminizerStar< F >::Element::state, DeterminizerStar< F >::Element::string, and DeterminizerStar< F >::Element::weight.

Referenced by fst::DeterminizeStar().

                                    {
    assert(!determinized_);
    // This determinizes the input fst but leaves it in the "special format"
    // in "output_arcs_".
    InputStateId start_id = ifst_->Start();
    if (start_id == kNoStateId) { determinized_ = true; return; } // Nothing to do.
    else {  // Insert start state into hash and queue.
      Element elem;
      elem.state = start_id;
      elem.weight = Weight::One();
      elem.string = repository_.IdOfEmpty();  // Id of empty sequence.
      std::vector<Element> vec;
      vec.push_back(elem);
      OutputStateId cur_id = SubsetToStateId(vec);
      assert(cur_id == 0 && "Do not call Determinize twice.");
    }
    while (!Q_.empty()) {
      std::pair<std::vector<Element>*, OutputStateId> cur_pair = Q_.front();
      Q_.pop_front();
      ProcessSubset(cur_pair);
      if (debug_ptr && *debug_ptr) Debug();  // will exit.
      if (max_states_ > 0 && output_arcs_.size() > max_states_) {
        if (allow_partial_ == false) {
          KALDI_ERR << "Determinization aborted since passed " << max_states_
                    << " states";
        } else {
          KALDI_WARN << "Determinization terminated since passed " << max_states_
                     << " states, partial results will be generated";
          is_partial_ = true;
          break;
        }
      }
    }
    determinized_ = true;
  }

FreeMostMemory()

void FreeMostMemory ( )

inline

Definition at line 229 of file determinize-star-inl.h.

                        {
    if (ifst_) {
      delete ifst_;
      ifst_ = NULL;
    }
    for (typename SubsetHash::iterator iter = hash_.begin();
        iter != hash_.end(); ++iter)
      delete iter->first;
    SubsetHash tmp;
    tmp.swap(hash_);
  }

IsPartial()

bool IsPartial ( )

inline

Definition at line 223 of file determinize-star-inl.h.

Referenced by fst::DeterminizeStar().

                   {
    return is_partial_;
  }

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( DeterminizerStar< F >  )

private

Output() [1/2]

void Output	(	MutableFst< GallicArc< Arc > > *	ofst,
		bool	destroy = true
	)

Definition at line 862 of file determinize-star-inl.h.

References rnnlm::i, DeterminizerStar< F >::TempArc::ilabel, DeterminizerStar< F >::TempArc::nextstate, DeterminizerStar< F >::TempArc::ostring, and DeterminizerStar< F >::TempArc::weight.

Referenced by fst::DeterminizeStar().

                                                 {
  assert(determinized_);
  if (destroy) determinized_ = false;
  typedef GallicWeight<Label, Weight> ThisGallicWeight;
  typedef typename Arc::StateId StateId;
  if (destroy)
    FreeMostMemory();
  StateId nStates = static_cast<StateId>(output_arcs_.size());
  ofst->DeleteStates();
  ofst->SetStart(kNoStateId);
  if (nStates == 0) {
    return;
  }
  for (StateId s = 0;s < nStates;s++) {
    OutputStateId news = ofst->AddState();
    assert(news == s);
  }
  ofst->SetStart(0);
  // now process transitions.
  for (StateId this_state = 0; this_state < nStates; this_state++) {
    std::vector<TempArc> &this_vec(output_arcs_[this_state]);
    typename std::vector<TempArc>::const_iterator iter = this_vec.begin(),
        end = this_vec.end();
    for (; iter != end; ++iter) {
      const TempArc &temp_arc(*iter);
      GallicArc<Arc> new_arc;
      std::vector<Label> seq;
      repository_.SeqOfId(temp_arc.ostring, &seq);
      StringWeight<Label, STRING_LEFT> string_weight;
      for (size_t i = 0;i < seq.size();i++) string_weight.PushBack(seq[i]);
      ThisGallicWeight gallic_weight(string_weight, temp_arc.weight);

      if (temp_arc.nextstate == kNoStateId) {  // is really final weight.
        ofst->SetFinal(this_state, gallic_weight);
      } else {  // is really an arc.
        new_arc.nextstate = temp_arc.nextstate;
        new_arc.ilabel = temp_arc.ilabel;
        new_arc.olabel = temp_arc.ilabel;  // acceptor.  input == output.
        new_arc.weight = gallic_weight;  // includes string and weight.
        ofst->AddArc(this_state, new_arc);
      }
    }
    // Free up memory.  Do this inside the loop as ofst is also allocating memory
    if (destroy) { std::vector<TempArc> temp; temp.swap(this_vec); }
  }
  if (destroy) { std::vector<std::vector<TempArc> > temp; temp.swap(output_arcs_); }
}

Output() [2/2]

void Output	(	MutableFst< Arc > *	ofst,
		bool	destroy = true
	)

Definition at line 912 of file determinize-star-inl.h.

References rnnlm::i, DeterminizerStar< F >::TempArc::ilabel, DeterminizerStar< F >::TempArc::nextstate, DeterminizerStar< F >::TempArc::ostring, DeterminizerStar< F >::ProcessTransition(), and DeterminizerStar< F >::TempArc::weight.

                                                                    {
  assert(determinized_);
  if (destroy) determinized_ = false;
  // Outputs to standard fst.
  OutputStateId num_states = static_cast<OutputStateId>(output_arcs_.size());
  if (destroy)
    FreeMostMemory();
  ofst->DeleteStates();
  if (num_states == 0) {
    ofst->SetStart(kNoStateId);
    return;
  }
  // Add basic states-- but will add extra ones to account for strings on output.
  for (OutputStateId s = 0; s < num_states; s++) {
    OutputStateId news = ofst->AddState();
    assert(news == s);
  }
  ofst->SetStart(0);
  for (OutputStateId this_state = 0; this_state < num_states; this_state++) {
    std::vector<TempArc> &this_vec(output_arcs_[this_state]);

    typename std::vector<TempArc>::const_iterator iter = this_vec.begin(),
        end = this_vec.end();
    for (; iter != end; ++iter) {
      const TempArc &temp_arc(*iter);
      std::vector<Label> seq;
      repository_.SeqOfId(temp_arc.ostring, &seq);
      if (temp_arc.nextstate == kNoStateId) {  // Really a final weight.
        // Make a sequence of states going to a final state, with the strings as labels.
        // Put the weight on the first arc.
        OutputStateId cur_state = this_state;
        for (size_t i = 0; i < seq.size();i++) {
          OutputStateId next_state = ofst->AddState();
          Arc arc;
          arc.nextstate = next_state;
          arc.weight = (i == 0 ? temp_arc.weight : Weight::One());
          arc.ilabel = 0;  // epsilon.
          arc.olabel = seq[i];
          ofst->AddArc(cur_state, arc);
          cur_state = next_state;
        }
        ofst->SetFinal(cur_state, (seq.size() == 0 ? temp_arc.weight : Weight::One()));
      } else {  // Really an arc.
        OutputStateId cur_state = this_state;
        // Have to be careful with this integer comparison (i+1 < seq.size()) because unsigned.
        // i < seq.size()-1 could fail for zero-length sequences.
        for (size_t i = 0; i+1 < seq.size();i++) {
          // for all but the last element of seq, create new state.
          OutputStateId next_state = ofst->AddState();
          Arc arc;
          arc.nextstate = next_state;
          arc.weight = (i == 0 ? temp_arc.weight : Weight::One());
          arc.ilabel = (i == 0 ? temp_arc.ilabel : 0);  // put ilabel on first element of seq.
          arc.olabel = seq[i];
          ofst->AddArc(cur_state, arc);
          cur_state = next_state;
        }
        // Add the final arc in the sequence.
        Arc arc;
        arc.nextstate = temp_arc.nextstate;
        arc.weight = (seq.size() <= 1 ? temp_arc.weight : Weight::One());
        arc.ilabel = (seq.size() <= 1 ? temp_arc.ilabel : 0);
        arc.olabel = (seq.size() > 0 ? seq.back() : 0);
        ofst->AddArc(cur_state, arc);
      }
    }
    // Free up memory.  Do this inside the loop as ofst is also allocating memory
    if (destroy) { std::vector<TempArc> temp; temp.swap(this_vec); }
  }
  if (destroy) {
    std::vector<std::vector<TempArc> > temp;
    temp.swap(output_arcs_);
    repository_.Destroy();
  }
}

ProcessFinal()

void ProcessFinal ( const std::vector< Element > &  closed_subset, OutputStateId  state  )

inlineprivate

Definition at line 435 of file determinize-star-inl.h.

References DeterminizerStar< F >::TempArc::ilabel, KALDI_ERR, DeterminizerStar< F >::TempArc::nextstate, DeterminizerStar< F >::TempArc::ostring, fst::Plus(), DeterminizerStar< F >::Element::state, DeterminizerStar< F >::Element::string, fst::Times(), DeterminizerStar< F >::Element::weight, and DeterminizerStar< F >::TempArc::weight.

                                                                                  {
    // processes final-weights for this subset.
    bool is_final = false;
    StringId final_string = 0;  // = 0 to keep compiler happy.
    Weight final_weight = Weight::One();  // This value will never be accessed, and
    // we just set it to avoid spurious compiler warnings.  We avoid setting it
    // to Zero() because floating-point infinities can sometimes generate
    // interrupts and slow things down.
    typename std::vector<Element>::const_iterator iter = closed_subset.begin(),
        end = closed_subset.end();
    for (; iter != end; ++iter) {
      const Element &elem = *iter;
      Weight this_final_weight = ifst_->Final(elem.state);
      if (this_final_weight != Weight::Zero()) {
        if (!is_final) {  // first final-weight
          final_string = elem.string;
          final_weight = Times(elem.weight, this_final_weight);
          is_final = true;
        } else {  // already have one.
          if (final_string != elem.string) {
            KALDI_ERR << "FST was not functional -> not determinizable";
          }
          final_weight = Plus(final_weight, Times(elem.weight, this_final_weight));
        }
      }
    }
    if (is_final) {
      // store final weights in TempArc structure, just like a transition.
      TempArc temp_arc;
      temp_arc.ilabel = 0;
      temp_arc.nextstate = kNoStateId;  // special marker meaning "final weight".
      temp_arc.ostring = final_string;
      temp_arc.weight = final_weight;
      output_arcs_[state].push_back(temp_arc);
    }
  }

ProcessSubset()

void ProcessSubset ( const std::pair< std::vector< Element > *, OutputStateId > &  pair )

inlineprivate

Definition at line 588 of file determinize-star-inl.h.

References StringRepository< Label, StringId >::KALDI_DISALLOW_COPY_AND_ASSIGN().

                                                                               {
    const std::vector<Element> *subset = pair.first;
    OutputStateId state = pair.second;

    std::vector<Element> closed_subset;  // subset after epsilon closure.
    epsilon_closure_.GetEpsilonClosure(*subset, &closed_subset);

    // Now follow non-epsilon arcs [and also process final states]
    ProcessFinal(closed_subset, state);

    // Now handle transitions out of these states.
    ProcessTransitions(closed_subset, state);
  }

ProcessTransition()

void ProcessTransition ( OutputStateId  state, Label  ilabel, std::vector< Element > *  subset  )

private

Definition at line 989 of file determinize-star-inl.h.

References fst::Divide(), rnnlm::i, DeterminizerStar< F >::TempArc::ilabel, KALDI_ERR, DeterminizerStar< F >::TempArc::nextstate, DeterminizerStar< F >::TempArc::ostring, fst::Plus(), and DeterminizerStar< F >::TempArc::weight.

Referenced by DeterminizerStar< F >::Output().

                                                                                 {
  // At input, "subset" may contain duplicates for a given dest state (but in sorted
  // order).  This function removes duplicates from "subset", normalizes it, and adds
  // a transition to the dest. state (possibly affecting Q_ and hash_, if state did not
  // exist).

  typedef typename std::vector<Element>::iterator IterType;
  {  // This block makes the subset have one unique Element per state, adding the weights.
    IterType cur_in = subset->begin(), cur_out = cur_in, end = subset->end();
    size_t num_out = 0;
    // Merge elements with same state-id
    while (cur_in != end) {  // while we have more elements to process.
      // At this point, cur_out points to location of next place we want to put an element,
      // cur_in points to location of next element we want to process.
      if (cur_in != cur_out) *cur_out = *cur_in;
      cur_in++;
      while (cur_in != end && cur_in->state == cur_out->state) {  // merge elements.
        if (cur_in->string != cur_out->string) {
          KALDI_ERR << "FST was not functional -> not determinizable";
        }
        cur_out->weight = Plus(cur_out->weight, cur_in->weight);
        cur_in++;
      }
      cur_out++;
      num_out++;
    }
    subset->resize(num_out);
  }

  StringId common_str;
  Weight tot_weight;
  {  // This block computes common_str and tot_weight (essentially: the common divisor)
    // and removes them from the elements.
    std::vector<Label> seq;

    IterType begin = subset->begin(), iter, end = subset->end();
    {  // This block computes "seq", which is the common prefix, and "common_str",
      // which is the StringId version of "seq".
      std::vector<Label> tmp_seq;
      for (iter = begin; iter != end; ++iter) {
        if (iter == begin) {
          repository_.SeqOfId(iter->string, &seq);
        } else {
          repository_.SeqOfId(iter->string, &tmp_seq);
          if (tmp_seq.size() < seq.size()) seq.resize(tmp_seq.size());  // size of shortest one.
          for (size_t i = 0; i < seq.size(); i++) // seq.size() is the shorter one at this point.
            if (tmp_seq[i] != seq[i]) seq.resize(i);
        }
        if (seq.size() == 0) break;  // will not get any prefix.
      }
      common_str = repository_.IdOfSeq(seq);
    }

    {  // This block computes "tot_weight".
      iter = begin;
      tot_weight = iter->weight;
      for (++iter; iter != end; ++iter)
        tot_weight = Plus(tot_weight, iter->weight);
    }

    // Now divide out common stuff from elements.
    size_t prefix_len = seq.size();
    for (iter = begin; iter != end; ++iter) {
      iter->weight = Divide(iter->weight, tot_weight);
      iter->string = repository_.RemovePrefix(iter->string, prefix_len);
    }
  }

  // Now add an arc to the state that the subset represents.
  // We may create a new state id for this (in SubsetToStateId).
  TempArc temp_arc;
  temp_arc.ilabel = ilabel;
  temp_arc.nextstate = SubsetToStateId(*subset);  // may or may not really add the subset.
  temp_arc.ostring = common_str;
  temp_arc.weight = tot_weight;
  output_arcs_[state].push_back(temp_arc);  // record the arc.
}

ProcessTransitions()

void ProcessTransitions ( const std::vector< Element > &  closed_subset, OutputStateId  state  )

inlineprivate

Definition at line 501 of file determinize-star-inl.h.

References DeterminizerStar< F >::Element::state, DeterminizerStar< F >::Element::string, fst::Times(), and DeterminizerStar< F >::Element::weight.

                                                                                        {
    std::vector<std::pair<Label, Element> > all_elems;
    {  // Push back into "all_elems", elements corresponding to all non-epsilon-input transitions
      // out of all states in "closed_subset".
      typename std::vector<Element>::const_iterator iter = closed_subset.begin(),
          end = closed_subset.end();
      for (; iter != end; ++iter) {
        const Element &elem = *iter;
        for (ArcIterator<Fst<Arc> > aiter(*ifst_, elem.state);
             !aiter.Done(); aiter.Next()) {
          const Arc &arc = aiter.Value();
          if (arc.ilabel != 0) {  // Non-epsilon transition -- ignore epsilons here.
            std::pair<Label, Element> this_pr;
            this_pr.first = arc.ilabel;
            Element &next_elem(this_pr.second);
            next_elem.state = arc.nextstate;
            next_elem.weight = Times(elem.weight, arc.weight);
            if (arc.olabel == 0) // output epsilon-- this is simple case so
                                 // handle separately for efficiency
              next_elem.string = elem.string;
            else {
              std::vector<Label> seq;
              repository_.SeqOfId(elem.string, &seq);
              seq.push_back(arc.olabel);
              next_elem.string = repository_.IdOfSeq(seq);
            }
            all_elems.push_back(this_pr);
          }
        }
      }
    }
    PairComparator pc;
    std::sort(all_elems.begin(), all_elems.end(), pc);
    // now sorted first on input label, then on state.
    typedef typename std::vector<std::pair<Label, Element> >::const_iterator PairIter;
    PairIter cur = all_elems.begin(), end = all_elems.end();
    std::vector<Element> this_subset;
    while (cur != end) {
      // Process ranges that share the same input symbol.
      Label ilabel = cur->first;
      this_subset.clear();
      while (cur != end && cur->first == ilabel) {
        this_subset.push_back(cur->second);
        cur++;
      }
      // We now have a subset for this ilabel.
      ProcessTransition(state, ilabel, &this_subset);
    }
  }

SubsetToStateId()

OutputStateId SubsetToStateId ( const std::vector< Element > &  subset )

inlineprivate

Definition at line 555 of file determinize-star-inl.h.

                                                                  {  // may add the subset to the queue.
    typedef typename SubsetHash::iterator IterType;
    IterType iter = hash_.find(&subset);
    if (iter == hash_.end()) {  // was not there.
      std::vector<Element> *new_subset = new std::vector<Element>(subset);
      OutputStateId new_state_id = (OutputStateId) output_arcs_.size();
      bool ans = hash_.insert(std::pair<const std::vector<Element>*,
                                        OutputStateId>(new_subset,
                                                       new_state_id)).second;
      assert(ans);
      output_arcs_.push_back(std::vector<TempArc>());
      if (allow_partial_ == false) {
        // If --allow-partial is not requested, we do the old way.
        Q_.push_front(std::pair<std::vector<Element>*, OutputStateId>(new_subset,  new_state_id));
      } else {
        // If --allow-partial is requested, we do breadth first search. This
        // ensures that when we return partial results, we return the states
        // that are reachable by the fewest steps from the start state.
        Q_.push_back(std::pair<std::vector<Element>*, OutputStateId>(new_subset,  new_state_id));
      }
      return new_state_id;
    } else {
      return iter->second;  // the OutputStateId.
    }
  }

Member Data Documentation

allow_partial_

bool allow_partial_

private

Definition at line 613 of file determinize-star-inl.h.

delta_

float delta_

private

Definition at line 610 of file determinize-star-inl.h.

determinized_

bool determinized_

private

Definition at line 612 of file determinize-star-inl.h.

epsilon_closure_

EpsilonClosure epsilon_closure_

private

Definition at line 620 of file determinize-star-inl.h.

equal_

SubsetEqual equal_

private

Definition at line 616 of file determinize-star-inl.h.

hash_

SubsetHash hash_

private

Definition at line 617 of file determinize-star-inl.h.

hasher_

SubsetKey hasher_

private

Definition at line 615 of file determinize-star-inl.h.

ifst_

const Fst<Arc>* ifst_

private

Definition at line 609 of file determinize-star-inl.h.

is_partial_

bool is_partial_

private

Definition at line 614 of file determinize-star-inl.h.

max_states_

int max_states_

private

Definition at line 611 of file determinize-star-inl.h.

output_arcs_

std::vector<std::vector<TempArc> > output_arcs_

private

Definition at line 607 of file determinize-star-inl.h.

Q_

std::deque<std::pair<std::vector<Element>*, OutputStateId> > Q_

private

Definition at line 605 of file determinize-star-inl.h.

repository_

StringRepository<Label, StringId> repository_

private

Definition at line 619 of file determinize-star-inl.h.

---

The documentation for this class was generated from the following file:

• fstext/determinize-star-inl.h