TrivialFactorWeightFstImpl< A, F > Class Template Reference

#include <trivial-factor-weight.h>

Inheritance diagram for TrivialFactorWeightFstImpl< A, F >:

Collaboration diagram for TrivialFactorWeightFstImpl< A, F >:

Classes
struct	Element
class	ElementEqual
class	ElementKey

Public Types
typedef A	Arc
typedef A::Label	Label
typedef A::Weight	Weight
typedef A::StateId	StateId
typedef F	FactorIterator
typedef DefaultCacheStore< A >	Store
typedef Store::State	State

Public Member Functions
	TrivialFactorWeightFstImpl (const Fst< A > &fst, const TrivialFactorWeightOptions< A > &opts)
	TrivialFactorWeightFstImpl (const TrivialFactorWeightFstImpl< A, F > &impl)
StateId	Start ()
Weight	Final (StateId s)
size_t	NumArcs (StateId s)
size_t	NumInputEpsilons (StateId s)
size_t	NumOutputEpsilons (StateId s)
void	InitArcIterator (StateId s, ArcIteratorData< A > *data)
StateId	FindState (const Element &e)
void	Expand (StateId s)

Private Types
typedef unordered_map< Element, StateId, ElementKey, ElementEqual >	ElementMap

Private Attributes
std::unique_ptr< const Fst< A > >	fst_
float	delta_
uint32	mode_
Label	extra_ilabel_
Label	extra_olabel_
std::vector< Element >	elements_
ElementMap	element_map_

Detailed Description

template<class A, class F>
class fst::internal::TrivialFactorWeightFstImpl< A, F >

Definition at line 92 of file trivial-factor-weight.h.

Member Typedef Documentation

Arc

typedef A Arc

Definition at line 106 of file trivial-factor-weight.h.

ElementMap

typedef unordered_map<Element, StateId, ElementKey, ElementEqual> ElementMap

private

Definition at line 294 of file trivial-factor-weight.h.

FactorIterator

typedef F FactorIterator

Definition at line 110 of file trivial-factor-weight.h.

Label

typedef A::Label Label

Definition at line 107 of file trivial-factor-weight.h.

State

typedef Store::State State

Definition at line 113 of file trivial-factor-weight.h.

StateId

typedef A::StateId StateId

Definition at line 109 of file trivial-factor-weight.h.

Store

typedef DefaultCacheStore<A> Store

Definition at line 112 of file trivial-factor-weight.h.

Weight

typedef A::Weight Weight

Definition at line 108 of file trivial-factor-weight.h.

Constructor & Destructor Documentation

TrivialFactorWeightFstImpl() [1/2]

TrivialFactorWeightFstImpl ( const Fst< A > &  fst, const TrivialFactorWeightOptions< A > &  opts  )

inline

Definition at line 124 of file trivial-factor-weight.h.

      : CacheImpl<A>(opts),
        fst_(fst.Copy()),
        delta_(opts.delta),
        extra_ilabel_(opts.extra_ilabel),
        extra_olabel_(opts.extra_olabel) {
    SetType("factor-weight");
    uint64 props = fst.Properties(kFstProperties, false);
    SetProperties(FactorWeightProperties(props), kCopyProperties);

    SetInputSymbols(fst.InputSymbols());
    SetOutputSymbols(fst.OutputSymbols());
  }

TrivialFactorWeightFstImpl() [2/2]

TrivialFactorWeightFstImpl ( const TrivialFactorWeightFstImpl< A, F > &  impl )

inline

Definition at line 138 of file trivial-factor-weight.h.

      : CacheImpl<A>(impl),
        fst_(impl.fst_->Copy(true)),
        delta_(impl.delta_),
        extra_ilabel_(impl.extra_ilabel_),
        extra_olabel_(impl.extra_olabel_) {
    SetType("factor-weight");
    SetProperties(impl.Properties(), kCopyProperties);
    SetInputSymbols(impl.InputSymbols());
    SetOutputSymbols(impl.OutputSymbols());
  }

Member Function Documentation

Expand()

void Expand ( StateId  s )

inline

Definition at line 230 of file trivial-factor-weight.h.

                         {
    CHECK(static_cast<size_t>(s) < elements_.size());
    Element e = elements_[s];
    if (e.weight != Weight::One()) {
      FactorIterator fit(e.weight);
      if (fit.Done()) {  // Cannot be factored-> create a link to dest state directly
        if (e.state != kNoStateId) {
          StateId dest = FindState(Element(e.state, Weight::One()));
          PushArc(s, Arc(extra_ilabel_, extra_olabel_, e.weight, dest));
        } // else we're done.  This is a final state.
      } else {  // Can be factored.
        const std::pair<Weight, Weight> &p = fit.Value();
        StateId dest = FindState(Element(e.state, p.second.Quantize(delta_)));
        PushArc(s, Arc(extra_ilabel_, extra_olabel_, p.first, dest));
      }
    } else {  // Unit weight.  This corresponds to a "real" state.
      CHECK(e.state != kNoStateId);
      for (ArcIterator< Fst<A> > ait(*fst_, e.state);
           !ait.Done();
           ait.Next()) {
        const A &arc = ait.Value();
        FactorIterator fit(arc.weight);
        if (fit.Done()) {  // cannot be factored->just link directly to dest.
          StateId dest = FindState(Element(arc.nextstate, Weight::One()));
          PushArc(s, Arc(arc.ilabel, arc.olabel, arc.weight, dest));
        } else {
          const std::pair<Weight, Weight> &p = fit.Value();
          StateId dest = FindState(Element(arc.nextstate, p.second.Quantize(delta_)));
          PushArc(s, Arc(arc.ilabel, arc.olabel, p.first, dest));
        }
      }
      // See if we have to add arcs for final-states [only if final-weight is factorable].
      Weight final_w = fst_->Final(e.state);
      if (final_w != Weight::Zero()) {
        FactorIterator fit(final_w);
        if (!fit.Done()) {
          const std::pair<Weight, Weight> &p = fit.Value();
          StateId dest = FindState(Element(kNoStateId, p.second.Quantize(delta_)));
          PushArc(s, Arc(extra_ilabel_, extra_olabel_, p.first, dest));
        }
      }
    }
    this->SetArcs(s);
  }

Final()

Weight Final ( StateId  s )

inline

Definition at line 161 of file trivial-factor-weight.h.

References TrivialFactorWeightFstImpl< A, F >::Element::state, and TrivialFactorWeightFstImpl< A, F >::Element::weight.

                          {
    if (!HasFinal(s)) {
      const Element &e = elements_[s];
      Weight w;
      if (e.state == kNoStateId) {  // extra state inserted to represent final weights.
        FactorIterator fit(e.weight);
        if (fit.Done()) {  // cannot be factored.
          w = e.weight;  // so it's final
        } else {
          w = Weight::Zero();  // need another transition.
        }
      } else {
        if (e.weight != Weight::One()) {  // Not a real state.
          w = Weight::Zero();
        } else {  // corresponds to a "real" state.
          w = fst_->Final(e.state);
          FactorIterator fit(w);
          if (!fit.Done()) // we would have intermediate states representing this final state.
            w = Weight::Zero();
        }
      }
      this->SetFinal(s, w);
      return w;
    } else {
      return CacheImpl<A>::Final(s);
    }
  }

FindState()

StateId FindState ( const Element &  e )

inline

Definition at line 216 of file trivial-factor-weight.h.

                                      {
    typename ElementMap::iterator eit = element_map_.find(e);
    if (eit != element_map_.end()) {
      return (*eit).second;
    } else {
      StateId s = elements_.size();
      elements_.push_back(e);
      element_map_.insert(std::pair<const Element, StateId>(e, s));
      return s;
    }
  }

InitArcIterator()

void InitArcIterator ( StateId  s, ArcIteratorData< A > *  data  )

inline

Definition at line 207 of file trivial-factor-weight.h.

                                                            {
    if (!HasArcs(s))
      Expand(s);
    CacheImpl<A>::InitArcIterator(s, data);
  }

NumArcs()

size_t NumArcs ( StateId  s )

inline

Definition at line 189 of file trivial-factor-weight.h.

References fst::NumArcs().

                            {
    if (!HasArcs(s))
      Expand(s);
    return CacheImpl<A>::NumArcs(s);
  }

NumInputEpsilons()

size_t NumInputEpsilons ( StateId  s )

inline

Definition at line 195 of file trivial-factor-weight.h.

                                     {
    if (!HasArcs(s))
      Expand(s);
    return CacheImpl<A>::NumInputEpsilons(s);
  }

NumOutputEpsilons()

size_t NumOutputEpsilons ( StateId  s )

inline

Definition at line 201 of file trivial-factor-weight.h.

                                      {
    if (!HasArcs(s))
      Expand(s);
    return CacheImpl<A>::NumOutputEpsilons(s);
  }

Start()

StateId Start ( )

inline

Definition at line 150 of file trivial-factor-weight.h.

                  {
    if (!HasStart()) {
      StateId s = fst_->Start();
      if (s == kNoStateId)
        return kNoStateId;
      StateId start = this->FindState(Element(fst_->Start(), Weight::One()));
      this->SetStart(start);
    }
    return CacheImpl<A>::Start();
  }

Member Data Documentation

delta_

float delta_

private

Definition at line 297 of file trivial-factor-weight.h.

element_map_

ElementMap element_map_

private

Definition at line 302 of file trivial-factor-weight.h.

elements_

std::vector<Element> elements_

private

Definition at line 301 of file trivial-factor-weight.h.

extra_ilabel_

Label extra_ilabel_

private

Definition at line 299 of file trivial-factor-weight.h.

extra_olabel_

Label extra_olabel_

private

Definition at line 300 of file trivial-factor-weight.h.

fst_

std::unique_ptr<const Fst<A> > fst_

private

Definition at line 296 of file trivial-factor-weight.h.

mode_

uint32 mode_

private

Definition at line 298 of file trivial-factor-weight.h.

---

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

• fstext/trivial-factor-weight.h