/*
* /// (non-Javadoc)
* ///
* /// @see java.lang.Object#equals(java.lang.Object)
*/
public override bool Equals(Object obj)
{
//Note: NOT performance critical
if (this == obj)
{
return(true);
}
if (obj == null)
{
return(false);
}
if (GetType() != obj.GetType())
{
return(false);
}
var other = (Fst)obj;
if (!Arrays.AreEqual(Isyms, other.Isyms))
{
return(false);
}
if (!Arrays.AreEqual(Osyms, other.Osyms))
{
return(false);
}
if (Start == null)
{
if (other.Start != null)
{
return(false);
}
}
else if (!Start.Equals(other.Start))
{
return(false);
}
if (_states == null)
{
if (other._states != null)
{
return(false);
}
}
else if (!Arrays.AreEqual(_states, other._states))
{
return(false);
}
if (Semiring == null)
{
if (other.Semiring != null)
{
return(false);
}
}
else if (!Semiring.Equals(other.Semiring))
{
return(false);
}
return(true);
}
/**
* /// Trims an Fst, removing states and arcs that are not on successful paths.
* ///
* /// @param fst the fst to trim
*/
public static void Apply(Fst fst)
{
Semiring semiring = fst.Semiring;
if (semiring == null)
{
Logger.LogInfo <Connect>("Fst has no semiring.");
return;
}
HashSet <State> accessible = new HashSet <State>();
HashSet <State> coaccessible = new HashSet <State>();
List <Arc>[] exploredArcs = new List <Arc> [fst.GetNumStates()];
List <List <State> > paths = new List <List <State> >();
paths.Add(new List <State>());
DepthFirstSearch(fst, accessible, paths, exploredArcs, coaccessible);
HashSet <State> toDelete = new HashSet <State>();
for (int i = 0; i < fst.GetNumStates(); i++)
{
State s = fst.GetState(i);
if (!(accessible.Contains(s) || coaccessible.Contains(s)))
{
toDelete.Add(s);
}
}
fst.DeleteStates(toDelete);
}
/**
* /// Computes the composition of two Fsts. The two Fsts are augmented in order
* /// to avoid multiple epsilon paths in the resulting Fst
* ///
* /// @param fst1 the first Fst
* /// @param fst2 the second Fst
* /// @param semiring the semiring to use in the operation
* /// @return the composed Fst
*/
public static Fst Get(Fst fst1, Fst fst2, Semiring semiring)
{
if ((fst1 == null) || (fst2 == null))
{
return(null);
}
if (!Arrays.AreEqual(fst1.Osyms, fst2.Isyms))
{
// symboltables do not match
return(null);
}
Fst filter = GetFilter(fst1.Osyms, semiring);
Augment(1, fst1, semiring);
Augment(0, fst2, semiring);
Fst tmp = compose(fst1, filter, semiring, false);
Fst res = compose(tmp, fst2, semiring, false);
// Connect.apply(res);
return(res);
}
/**
* /// Augments the labels of an Fst in order to use it for composition avoiding
* /// multiple epsilon paths in the resulting Fst
* ///
* /// Augment can be applied to both {@link edu.cmu.sphinx.fst.Fst} and
* /// {@link edu.cmu.sphinx.fst.ImmutableFst}, as immutable fsts hold an
* /// additional null arc for that operation
* ///
* /// @param label constant denoting if the augment should take place on input
* /// or output labels For value equal to 0 augment will take place
* /// for input labels For value equal to 1 augment will take place
* /// for output labels
* /// @param fst the fst to augment
* /// @param semiring the semiring to use in the operation
*/
public static void Augment(int label, Fst fst, Semiring semiring)
{
// label: 0->augment on ilabel
// 1->augment on olabel
String[] isyms = fst.Isyms;
String[] osyms = fst.Osyms;
int e1InputIndex = isyms == null ? 0 : isyms.Length;
int e2InputIndex = isyms == null ? 1 : isyms.Length + 1;
int e1OutputIndex = osyms == null ? 0 : osyms.Length;
int e2OutputIndex = osyms == null ? 1 : osyms.Length + 1;
int numStates = fst.GetNumStates();
for (int i = 0; i < numStates; i++)
{
State s = fst.GetState(i);
// Immutable fsts hold an additional (null) arc for augmention
int numArcs = (fst is ImmutableFst) ? s.GetNumArcs() - 1
: s.GetNumArcs();
for (int j = 0; j < numArcs; j++)
{
Arc a = s.GetArc(j);
if ((label == 1) && (a.Olabel == 0))
{
a.Olabel = e2OutputIndex;
}
else if ((label == 0) && (a.Ilabel == 0))
{
a.Ilabel = e1InputIndex;
}
}
if (label == 0)
{
if (fst is ImmutableFst)
{
s.SetArc(numArcs, new Arc(e2InputIndex, 0, semiring.One,
s));
}
else
{
s.AddArc(new Arc(e2InputIndex, 0, semiring.One, s));
}
}
else if (label == 1)
{
if (fst is ImmutableFst)
{
s.SetArc(numArcs, new Arc(0, e1OutputIndex, semiring.One,
s));
}
else
{
s.AddArc(new Arc(0, e1OutputIndex, semiring.One, s));
}
}
}
}
public static void apply(Fst fst)
{
Semiring semiring = fst.getSemiring();
ArrayList arrayList = new ArrayList();
int numStates = fst.getNumStates();
for (int i = 0; i < numStates; i++)
{
State state = fst.getState(i);
if (state.getFinalWeight() != semiring.zero())
{
arrayList.add(state);
}
}
State state2 = new State(semiring.one());
fst.addState(state2);
Iterator iterator = arrayList.iterator();
while (iterator.hasNext())
{
State state3 = (State)iterator.next();
state3.addArc(new Arc(0, 0, state3.getFinalWeight(), state2));
state3.setFinalWeight(semiring.zero());
}
}
/**
* /// Extends an Fst to a single final state.
* ///
* /// It adds a new final state with a 0.0 (Semiring's 1) final wight and
* /// connects the current final states to it using epsilon transitions with
* /// weight equal to the original final state's weight.
* ///
* /// @param fst the Fst to extend
*/
public static void Apply(Fst fst)
{
Semiring semiring = fst.Semiring;
List <State> fStates = new List <State>();
int numStates = fst.GetNumStates();
for (int i = 0; i < numStates; i++)
{
State s = fst.GetState(i);
if (s.FinalWeight != semiring.Zero)
{
fStates.Add(s);
}
}
// Add a new single final
State newFinal = new State(semiring.One);
fst.AddState(newFinal);
foreach (State s in fStates)
{
// add epsilon transition from the old final to the new one
s.AddArc(new Arc(0, 0, s.FinalWeight, newFinal));
// set old state's weight to zero
s.FinalWeight = semiring.Zero;
}
}
private static void calcClosure(Fst fst, State state, HashMap[] array, Semiring semiring)
{
int numArcs = state.getNumArcs();
for (int i = 0; i < numArcs; i++)
{
Arc arc = state.getArc(i);
if (arc.getIlabel() == 0 && arc.getOlabel() == 0)
{
if (array[arc.getNextState().getId()] == null)
{
RmEpsilon.calcClosure(fst, arc.getNextState(), array, semiring);
}
if (array[arc.getNextState().getId()] != null)
{
Iterator iterator = array[arc.getNextState().getId()].keySet().iterator();
while (iterator.hasNext())
{
State state2 = (State)iterator.next();
float num = semiring.times(RmEpsilon.getPathWeight(arc.getNextState(), state2, array).floatValue(), arc.getWeight());
RmEpsilon.add(state, state2, num, array, semiring);
}
}
RmEpsilon.add(state, arc.getNextState(), arc.getWeight(), array, semiring);
}
}
}
/**
* /// Reverses an fst
* ///
* /// @param fst the fst to reverse
* /// @return the reversed fst
*/
public static Fst Get(Fst fst)
{
if (fst.Semiring == null)
{
return(null);
}
ExtendFinal.Apply(fst);
Semiring semiring = fst.Semiring;
Fst res = new Fst(fst.GetNumStates());
res.Semiring = semiring;
res.Isyms = fst.Osyms;
res.Osyms = fst.Isyms;
State[] stateMap = new State[fst.GetNumStates()];
int numStates = fst.GetNumStates();
for (int i = 0; i < numStates; i++)
{
State _is = fst.GetState(i);
State s = new State(semiring.Zero);
res.AddState(s);
stateMap[_is.GetId()] = s;
if (_is.FinalWeight != semiring.Zero)
{
res.SetStart(s);
}
}
stateMap[fst.Start.GetId()].FinalWeight = semiring.One;
for (int i = 0; i < numStates; i++)
{
State olds = fst.GetState(i);
State news = stateMap[olds.GetId()];
int numArcs = olds.GetNumArcs();
for (int j = 0; j < numArcs; j++)
{
Arc olda = olds.GetArc(j);
State next = stateMap[olda.NextState.GetId()];
Arc newa = new Arc(olda.Ilabel, olda.Olabel,
semiring.Reverse(olda.Weight), news);
next.AddArc(newa);
}
}
ExtendFinal.Undo(fst);
return(res);
}
/**
* /// Get a filter to use for avoiding multiple epsilon paths in the resulting
* /// Fst
* ///
* /// See: M. Mohri, "Weighted automata algorithms", Handbook of Weighted
* /// Automata. Springer, pp. 213-250, 2009.
* ///
* /// @param syms the gilter's input/output symbols
* /// @param semiring the semiring to use in the operation
* /// @return the filter
*/
public static Fst GetFilter(String[] syms, Semiring semiring)
{
Fst filter = new Fst(semiring);
if (syms == null)
{
return(filter); //empty one
}
int e1Index = syms == null ? 0 : syms.Length;
int e2Index = syms == null ? 1 : syms.Length + 1;
filter.Isyms = syms;
filter.Osyms = syms;
// State 0
State s0 = new State(syms.Length + 3);
s0.FinalWeight = semiring.One;
State s1 = new State(syms.Length);
s1.FinalWeight = semiring.One;
State s2 = new State(syms.Length);
s2.FinalWeight = semiring.One;
filter.AddState(s0);
s0.AddArc(new Arc(e2Index, e1Index, semiring.One, s0));
s0.AddArc(new Arc(e1Index, e1Index, semiring.One, s1));
s0.AddArc(new Arc(e2Index, e2Index, semiring.One, s2));
for (int i = 1; i < syms.Length; i++)
{
s0.AddArc(new Arc(i, i, semiring.One, s0));
}
filter.SetStart(s0);
// State 1
filter.AddState(s1);
s1.AddArc(new Arc(e1Index, e1Index, semiring.One, s1));
for (int i = 1; i < syms.Length; i++)
{
s1.AddArc(new Arc(i, i, semiring.One, s0));
}
// State 2
filter.AddState(s2);
s2.AddArc(new Arc(e2Index, e2Index, semiring.One, s2));
for (int i = 1; i < syms.Length; i++)
{
s2.AddArc(new Arc(i, i, semiring.One, s0));
}
return(filter);
}
public static void augment(int label, Fst fst, Semiring semiring)
{
string[] isyms = fst.getIsyms();
string[] osyms = fst.getOsyms();
int ilabel = isyms.Length;
int iLabel = isyms.Length + 1;
int oLabel = osyms.Length;
int olabel = osyms.Length + 1;
int numStates = fst.getNumStates();
for (int i = 0; i < numStates; i++)
{
State state = fst.getState(i);
int num = (!(fst is ImmutableFst)) ? state.getNumArcs() : (state.getNumArcs() - 1);
for (int j = 0; j < num; j++)
{
Arc arc = state.getArc(j);
if (label == 1 && arc.getOlabel() == 0)
{
arc.setOlabel(olabel);
}
else if (label == 0 && arc.getIlabel() == 0)
{
arc.setIlabel(ilabel);
}
}
if (label == 0)
{
if (fst is ImmutableFst)
{
state.setArc(num, new Arc(iLabel, 0, semiring.one(), state));
}
else
{
state.addArc(new Arc(iLabel, 0, semiring.one(), state));
}
}
else if (label == 1)
{
if (fst is ImmutableFst)
{
state.setArc(num, new Arc(0, oLabel, semiring.one(), state));
}
else
{
state.addArc(new Arc(0, oLabel, semiring.one(), state));
}
}
}
}
/**
* /// Deserializes an ImmutableFst from an ObjectInputStream
* ///
* /// @param in
* /// the ObjectInputStream. It should be already be initialized by
* /// the caller.
* /// @return
* /// @throws IOException
* /// @throws ClassNotFoundException
*/
private static ImmutableFst ReadImmutableFst(Stream inStream)
{
BinaryFormatter serializer = new BinaryFormatter();
String[] _is = ReadStringMap(inStream);
String[] os = ReadStringMap(inStream);
int startid = (int)serializer.Deserialize(inStream);
Semiring semiring = (Semiring)serializer.Deserialize(inStream);
int numStates = (int)serializer.Deserialize(inStream);
ImmutableFst res = new ImmutableFst(numStates);
res.Isyms = _is;
res.Osyms = os;
res.Semiring = semiring;
for (int i = 0; i < numStates; i++)
{
int numArcs = (int)serializer.Deserialize(inStream);
ImmutableState s = new ImmutableState(numArcs + 1);
float f = (float)serializer.Deserialize(inStream);
if (f == res.Semiring.Zero)
{
f = res.Semiring.Zero;
}
else if (f == res.Semiring.One)
{
f = res.Semiring.One;
}
s.FinalWeight = f;
s.Id = (int)serializer.Deserialize(inStream);
res._states[s.GetId()] = s;
}
res.SetStart(res._states[startid]);
numStates = res._states.Length;
for (int i = 0; i < numStates; i++)
{
ImmutableState s1 = res._states[i];
for (int j = 0; j < s1.InitialNumArcs - 1; j++)
{
Arc a = new Arc();
a.Ilabel = (int)serializer.Deserialize(inStream);
a.Olabel = (int)serializer.Deserialize(inStream);
a.Weight = (float)serializer.Deserialize(inStream);
a.NextState = res._states[(int)serializer.Deserialize(inStream)];
s1.SetArc(j, a);
}
}
return(res);
}
private static Fst readFst(ObjectInputStream objectInputStream)
{
string[] array = Fst.readStringMap(objectInputStream);
string[] array2 = Fst.readStringMap(objectInputStream);
int num = objectInputStream.readInt();
Semiring semiring = (Semiring)objectInputStream.readObject();
int num2 = objectInputStream.readInt();
Fst fst = new Fst(num2);
fst.isyms = array;
fst.osyms = array2;
fst.semiring = semiring;
for (int i = 0; i < num2; i++)
{
int num3 = objectInputStream.readInt();
State state = new State(num3 + 1);
float num4 = objectInputStream.readFloat();
if (num4 == fst.semiring.zero())
{
num4 = fst.semiring.zero();
}
else if (num4 == fst.semiring.one())
{
num4 = fst.semiring.one();
}
state.setFinalWeight(num4);
state.id = objectInputStream.readInt();
fst.states.add(state);
}
fst.setStart((State)fst.states.get(num));
num2 = fst.getNumStates();
for (int i = 0; i < num2; i++)
{
State state2 = fst.getState(i);
for (int j = 0; j < state2.initialNumArcs - 1; j++)
{
Arc arc = new Arc();
arc.setIlabel(objectInputStream.readInt());
arc.setOlabel(objectInputStream.readInt());
arc.setWeight(objectInputStream.readFloat());
arc.setNextState((State)fst.states.get(objectInputStream.readInt()));
state2.addArc(arc);
}
}
return(fst);
}
private static ImmutableFst readImmutableFst(ObjectInputStream objectInputStream)
{
string[] isyms = Fst.readStringMap(objectInputStream);
string[] osyms = Fst.readStringMap(objectInputStream);
int num = objectInputStream.readInt();
Semiring semiring = (Semiring)objectInputStream.readObject();
int num2 = objectInputStream.readInt();
ImmutableFst immutableFst = new ImmutableFst(num2);
immutableFst.isyms = isyms;
immutableFst.osyms = osyms;
immutableFst.semiring = semiring;
for (int i = 0; i < num2; i++)
{
int num3 = objectInputStream.readInt();
ImmutableState immutableState = new ImmutableState(num3 + 1);
float num4 = objectInputStream.readFloat();
if (num4 == immutableFst.semiring.zero())
{
num4 = immutableFst.semiring.zero();
}
else if (num4 == immutableFst.semiring.one())
{
num4 = immutableFst.semiring.one();
}
immutableState.setFinalWeight(num4);
immutableState.id = objectInputStream.readInt();
immutableFst.states[immutableState.getId()] = immutableState;
}
immutableFst.setStart(immutableFst.states[num]);
num2 = immutableFst.states.Length;
for (int i = 0; i < num2; i++)
{
ImmutableState immutableState2 = immutableFst.states[i];
for (int j = 0; j < immutableState2.initialNumArcs - 1; j++)
{
Arc arc = new Arc();
arc.setIlabel(objectInputStream.readInt());
arc.setOlabel(objectInputStream.readInt());
arc.setWeight(objectInputStream.readFloat());
arc.setNextState(immutableFst.states[objectInputStream.readInt()]);
immutableState2.setArc(j, arc);
}
}
return(immutableFst);
}
public static Fst get(Fst fst1, Fst fst2, Semiring semiring)
{
if (fst1 == null || fst2 == null)
{
return(null);
}
if (!Arrays.equals(fst1.getOsyms(), fst2.getIsyms()))
{
return(null);
}
Fst filter = Compose.getFilter(fst1.getOsyms(), semiring);
Compose.augment(1, fst1, semiring);
Compose.augment(0, fst2, semiring);
Fst fst3 = Compose.compose(fst1, filter, semiring, false);
return(Compose.compose(fst3, fst2, semiring, false));
}
public static Fst get(Fst fst)
{
if (fst.getSemiring() == null)
{
return(null);
}
ExtendFinal.apply(fst);
Semiring semiring = fst.getSemiring();
Fst fst2 = new Fst(fst.getNumStates());
fst2.setSemiring(semiring);
fst2.setIsyms(fst.getOsyms());
fst2.setOsyms(fst.getIsyms());
State[] array = new State[fst.getNumStates()];
int numStates = fst.getNumStates();
for (int i = 0; i < numStates; i++)
{
State state = fst.getState(i);
State state2 = new State(semiring.zero());
fst2.addState(state2);
array[state.getId()] = state2;
if (state.getFinalWeight() != semiring.zero())
{
fst2.setStart(state2);
}
}
array[fst.getStart().getId()].setFinalWeight(semiring.one());
for (int i = 0; i < numStates; i++)
{
State state = fst.getState(i);
State state2 = array[state.getId()];
int numArcs = state.getNumArcs();
for (int j = 0; j < numArcs; j++)
{
Arc arc = state.getArc(j);
State state3 = array[arc.getNextState().getId()];
Arc arc2 = new Arc(arc.getIlabel(), arc.getOlabel(), semiring.reverse(arc.getWeight()), state2);
state3.addArc(arc2);
}
}
ExtendFinal.undo(fst);
return(fst2);
}
public static float[] shortestDistance(Fst fst)
{
Fst fst2 = Reverse.get(fst);
float[] array = new float[fst2.getNumStates()];
float[] array2 = new float[fst2.getNumStates()];
Semiring semiring = fst2.getSemiring();
Arrays.fill(array, semiring.zero());
Arrays.fill(array2, semiring.zero());
LinkedHashSet linkedHashSet = new LinkedHashSet();
linkedHashSet.add(fst2.getStart());
array[fst2.getStart().getId()] = semiring.one();
array2[fst2.getStart().getId()] = semiring.one();
while (!linkedHashSet.isEmpty())
{
State state = (State)linkedHashSet.iterator().next();
linkedHashSet.remove(state);
float f = array2[state.getId()];
array2[state.getId()] = semiring.zero();
for (int i = 0; i < state.getNumArcs(); i++)
{
Arc arc = state.getArc(i);
State nextState = arc.getNextState();
float num = array[arc.getNextState().getId()];
float num2 = semiring.plus(num, semiring.times(f, arc.getWeight()));
if (num != num2)
{
array[arc.getNextState().getId()] = num2;
array2[arc.getNextState().getId()] = semiring.plus(array2[arc.getNextState().getId()], semiring.times(f, arc.getWeight()));
if (!linkedHashSet.contains(nextState))
{
linkedHashSet.add(nextState);
}
}
}
}
return(array);
}
public static Fst getFilter(string[] syms, Semiring semiring)
{
Fst fst = new Fst(semiring);
int num = syms.Length;
int num2 = syms.Length + 1;
fst.setIsyms(syms);
fst.setOsyms(syms);
State state = new State(syms.Length + 3);
state.setFinalWeight(semiring.one());
State state2 = new State(syms.Length);
state2.setFinalWeight(semiring.one());
State state3 = new State(syms.Length);
state3.setFinalWeight(semiring.one());
fst.addState(state);
state.addArc(new Arc(num2, num, semiring.one(), state));
state.addArc(new Arc(num, num, semiring.one(), state2));
state.addArc(new Arc(num2, num2, semiring.one(), state3));
for (int i = 1; i < syms.Length; i++)
{
state.addArc(new Arc(i, i, semiring.one(), state));
}
fst.setStart(state);
fst.addState(state2);
state2.addArc(new Arc(num, num, semiring.one(), state2));
for (int i = 1; i < syms.Length; i++)
{
state2.addArc(new Arc(i, i, semiring.one(), state));
}
fst.addState(state3);
state3.addArc(new Arc(num2, num2, semiring.one(), state3));
for (int i = 1; i < syms.Length; i++)
{
state3.addArc(new Arc(i, i, semiring.one(), state));
}
return(fst);
}
public virtual ArrayList phoneticize(ArrayList entry, int nbest)
{
Fst fst = this.entryToFSA(entry);
Semiring semiring = fst.getSemiring();
Compose.augment(1, fst, semiring);
ArcSort.apply(fst, new OLabelCompare());
Fst fst2 = Compose.compose(fst, this.epsilonFilter, semiring, true);
ArcSort.apply(fst2, new OLabelCompare());
fst2 = Compose.compose(fst2, this.g2pmodel, semiring, true);
Project.apply(fst2, ProjectType.__OUTPUT);
if (nbest == 1)
{
fst2 = NShortestPaths.get(fst2, 1, false);
}
else
{
fst2 = NShortestPaths.get(fst2, nbest * 10, false);
}
fst2 = RmEpsilon.get(fst2);
return(this.findAllPaths(fst2, nbest, this.skipSeqs, this.tie));
}
/**
* /// Calculate the epsilon closure
*/
private static void CalcClosure(Fst fst, State state, Dictionary <State, float>[] cl, Semiring semiring)
{
var s = state;
float pathWeight;
var numArcs = s.GetNumArcs();
for (var j = 0; j < numArcs; j++)
{
var a = s.GetArc(j);
if ((a.Ilabel == 0) && (a.Olabel == 0))
{
if (cl[a.NextState.GetId()] == null)
{
CalcClosure(fst, a.NextState, cl, semiring);
}
if (cl[a.NextState.GetId()] != null)
{
foreach (var pathFinalState in cl[a.NextState.GetId()].Keys)
{
pathWeight = semiring.Times(
GetPathWeight(a.NextState, pathFinalState,
cl), a.Weight);
Add(state, pathFinalState, pathWeight, cl, semiring);
}
}
Add(state, a.NextState, a.Weight, cl, semiring);
}
}
}
/**
* /// Add a state in the epsilon closure
*/
private static void Add(State fromState, State toState, float weight, Dictionary <State, float>[] cl, Semiring semiring)
{
var old = GetPathWeight(fromState, toState, cl);
if (old == float.NaN)
{
Put(fromState, toState, weight, cl);
}
else
{
Put(fromState, toState, semiring.Plus(weight, old), cl);
}
}
/**
* /// Determinizes an fst. The result will be an equivalent fst that has the
* /// property that no state has two transitions with the same input label. For
* /// this algorithm, epsilon transitions are treated as regular symbols.
* ///
* /// @param fst the fst to determinize
* /// @return the determinized fst
*/
public static Fst Get(Fst fst)
{
if (fst.Semiring == null)
{
// semiring not provided
return(null);
}
// initialize the queue and new fst
Semiring semiring = fst.Semiring;
Fst res = new Fst(semiring);
res.Isyms = fst.Isyms;
res.Osyms = fst.Osyms;
// stores the queue (item in index 0 is next)
Queue <List <Pair <State, float> > > queue = new Queue <List <Pair <State, float> > >();
Dictionary <String, State> stateMapper = new Dictionary <String, State>();
State s = new State(semiring.Zero);
string stateString = "(" + fst.Start + "," + semiring.One + ")";
queue.Enqueue(new List <Pair <State, float> >());
queue.Peek().Add(new Pair <State, float>(fst.Start, semiring.One));
res.AddState(s);
stateMapper.Add(stateString, s);
res.SetStart(s);
while (queue.Count != 0)
{
List <Pair <State, float> > p = queue.Dequeue();
State pnew = GetStateLabel(p, stateMapper);
//queueRemoveAt(0);
List <int> labels = GetUniqueLabels(fst, p);
foreach (int label in labels)
{
float wnew = semiring.Zero;
// calc w'
foreach (Pair <State, float> ps in p)
{
State old = ps.GetLeft();
float u = ps.GetRight();
int numArcs = old.GetNumArcs();
for (int j = 0; j < numArcs; j++)
{
Arc arc = old.GetArc(j);
if (label == arc.Ilabel)
{
wnew = semiring.Plus(wnew,
semiring.Times(u, arc.Weight));
}
}
}
// calc new states
// keep residual weights to variable forQueue
List <Pair <State, float> > forQueue = new List <Pair <State, float> >();
foreach (Pair <State, float> ps in p)
{
State old = ps.GetLeft();
float u = ps.GetRight();
float wnewRevert = semiring.Divide(semiring.One, wnew);
int numArcs = old.GetNumArcs();
for (int j = 0; j < numArcs; j++)
{
Arc arc = old.GetArc(j);
if (label == arc.Ilabel)
{
State oldstate = arc.NextState;
Pair <State, float> pair = GetPair(forQueue,
oldstate, semiring.Zero);
pair.SetRight(semiring.Plus(
pair.GetRight(),
semiring.Times(wnewRevert,
semiring.Times(u, arc.Weight))));
}
}
}
// build new state's id and new elements for queue
string qnewid = "";
foreach (Pair <State, float> ps in forQueue)
{
State old = ps.GetLeft();
float unew = ps.GetRight();
if (!qnewid.Equals(""))
{
qnewid = qnewid + ",";
}
qnewid = qnewid + "(" + old + "," + unew + ")";
}
if (stateMapper.Get(qnewid) == null)
{
State qnew = new State(semiring.Zero);
res.AddState(qnew);
stateMapper.Add(qnewid, qnew);
// update new state's weight
float fw = qnew.FinalWeight;
foreach (Pair <State, float> ps in forQueue)
{
fw = semiring.Plus(fw, semiring.Times(ps.GetLeft().FinalWeight, ps.GetRight()));
}
qnew.FinalWeight = fw;
queue.Enqueue(forQueue);
}
pnew.AddArc(new Arc(label, label, wnew, stateMapper[qnewid]));
}
}
return(res);
}
public Fst(Semiring s) : this()
{
this.semiring = s;
}
public virtual void setSemiring(Semiring semiring)
{
this.semiring = semiring;
}
public static Fst importFst(string basename, Semiring semiring)
{
Fst fst = new Fst(semiring);
HashMap hashMap = Convert.importSymbols(new StringBuilder().append(basename).append(".input.syms").toString());
if (hashMap == null)
{
hashMap = new HashMap();
hashMap.put("<eps>", Integer.valueOf(0));
}
HashMap hashMap2 = Convert.importSymbols(new StringBuilder().append(basename).append(".output.syms").toString());
if (hashMap2 == null)
{
hashMap2 = new HashMap();
hashMap2.put("<eps>", Integer.valueOf(0));
}
HashMap hashMap3 = Convert.importSymbols(new StringBuilder().append(basename).append(".states.syms").toString());
FileInputStream fileInputStream = new FileInputStream(new StringBuilder().append(basename).append(".fst.txt").toString());
DataInputStream dataInputStream = new DataInputStream(fileInputStream);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(dataInputStream, "UTF-8"));
int num = 1;
HashMap hashMap4 = new HashMap();
string text;
while ((text = bufferedReader.readLine()) != null)
{
string[] array = String.instancehelper_split(text, "\\t");
Integer integer;
if (hashMap3 == null)
{
integer = Integer.valueOf(Integer.parseInt(array[0]));
}
else
{
integer = (Integer)hashMap3.get(array[0]);
}
State state = (State)hashMap4.get(integer);
if (state == null)
{
state = new State(semiring.zero());
fst.addState(state);
hashMap4.put(integer, state);
}
if (num != 0)
{
num = 0;
fst.setStart(state);
}
if (array.Length > 2)
{
Integer integer2;
if (hashMap3 == null)
{
integer2 = Integer.valueOf(Integer.parseInt(array[1]));
}
else
{
integer2 = (Integer)hashMap3.get(array[1]);
}
State state2 = (State)hashMap4.get(integer2);
if (state2 == null)
{
state2 = new State(semiring.zero());
fst.addState(state2);
hashMap4.put(integer2, state2);
}
if (hashMap.get(array[2]) == null)
{
hashMap.put(array[2], Integer.valueOf(hashMap.size()));
}
int iLabel = ((Integer)hashMap.get(array[2])).intValue();
if (hashMap2.get(array[3]) == null)
{
hashMap2.put(array[3], Integer.valueOf(hashMap2.size()));
}
int oLabel = ((Integer)hashMap2.get(array[3])).intValue();
float weight;
if (array.Length > 4)
{
weight = Float.parseFloat(array[4]);
}
else
{
weight = 0f;
}
Arc arc = new Arc(iLabel, oLabel, weight, state2);
state.addArc(arc);
}
else if (array.Length > 1)
{
float finalWeight = Float.parseFloat(array[1]);
state.setFinalWeight(finalWeight);
}
else
{
state.setFinalWeight(0f);
}
}
dataInputStream.close();
fst.setIsyms(Utils.toStringArray(hashMap));
fst.setOsyms(Utils.toStringArray(hashMap2));
return(fst);
}
public static Fst get(Fst fst)
{
if (fst.getSemiring() == null)
{
return(null);
}
Semiring semiring = fst.getSemiring();
Fst fst2 = new Fst(semiring);
fst2.setIsyms(fst.getIsyms());
fst2.setOsyms(fst.getOsyms());
LinkedList linkedList = new LinkedList();
HashMap hashMap = new HashMap();
State state = new State(semiring.zero());
string text = new StringBuilder().append("(").append(fst.getStart()).append(",").append(semiring.one()).append(")").toString();
linkedList.add(new ArrayList());
((ArrayList)linkedList.peek()).add(new Pair(fst.getStart(), Float.valueOf(semiring.one())));
fst2.addState(state);
hashMap.put(text, state);
fst2.setStart(state);
while (!linkedList.isEmpty())
{
ArrayList arrayList = (ArrayList)linkedList.remove();
State stateLabel = Determinize.getStateLabel(arrayList, hashMap);
ArrayList uniqueLabels = Determinize.getUniqueLabels(fst, arrayList);
Iterator iterator = uniqueLabels.iterator();
while (iterator.hasNext())
{
int num = ((Integer)iterator.next()).intValue();
Float @float = Float.valueOf(semiring.zero());
Iterator iterator2 = arrayList.iterator();
while (iterator2.hasNext())
{
Pair pair = (Pair)iterator2.next();
State state2 = (State)pair.getLeft();
Float float2 = (Float)pair.getRight();
int numArcs = state2.getNumArcs();
for (int i = 0; i < numArcs; i++)
{
Arc arc = state2.getArc(i);
if (num == arc.getIlabel())
{
@float = Float.valueOf(semiring.plus(@float.floatValue(), semiring.times(float2.floatValue(), arc.getWeight())));
}
}
}
ArrayList arrayList2 = new ArrayList();
Iterator iterator3 = arrayList.iterator();
while (iterator3.hasNext())
{
Pair pair2 = (Pair)iterator3.next();
State state3 = (State)pair2.getLeft();
Float float3 = (Float)pair2.getRight();
Float float4 = Float.valueOf(semiring.divide(semiring.one(), @float.floatValue()));
int numArcs2 = state3.getNumArcs();
for (int j = 0; j < numArcs2; j++)
{
Arc arc2 = state3.getArc(j);
if (num == arc2.getIlabel())
{
State nextState = arc2.getNextState();
Pair pair3 = Determinize.getPair(arrayList2, nextState, Float.valueOf(semiring.zero()));
pair3.setRight(Float.valueOf(semiring.plus(((Float)pair3.getRight()).floatValue(), semiring.times(float4.floatValue(), semiring.times(float3.floatValue(), arc2.getWeight())))));
}
}
}
string text2 = "";
Iterator iterator4 = arrayList2.iterator();
while (iterator4.hasNext())
{
Pair pair4 = (Pair)iterator4.next();
State state4 = (State)pair4.getLeft();
Float float4 = (Float)pair4.getRight();
if (!String.instancehelper_equals(text2, ""))
{
text2 = new StringBuilder().append(text2).append(",").toString();
}
text2 = new StringBuilder().append(text2).append("(").append(state4).append(",").append(float4).append(")").toString();
}
if (hashMap.get(text2) == null)
{
State state2 = new State(semiring.zero());
fst2.addState(state2);
hashMap.put(text2, state2);
Float float2 = Float.valueOf(state2.getFinalWeight());
Iterator iterator5 = arrayList2.iterator();
while (iterator5.hasNext())
{
Pair pair5 = (Pair)iterator5.next();
float2 = Float.valueOf(semiring.plus(float2.floatValue(), semiring.times(((State)pair5.getLeft()).getFinalWeight(), ((Float)pair5.getRight()).floatValue())));
}
state2.setFinalWeight(float2.floatValue());
linkedList.add(arrayList2);
}
stateLabel.addArc(new Arc(num, num, @float.floatValue(), (State)hashMap.get(text2)));
}
}
return(fst2);
}
/**
* /// Constructor specifying the fst's semiring
* ///
* /// @param s
* /// the fst's semiring
*/
public Fst(Semiring s) : this()
{
Semiring = s;
}
private ArrayList findAllPaths(Fst fst, int num, HashSet hashSet, string text)
{
Semiring semiring = fst.getSemiring();
HashMap hashMap = new HashMap();
HashMap hashMap2 = new HashMap();
LinkedList linkedList = new LinkedList();
Path path = new Path(fst.getSemiring());
path.setCost(semiring.one());
hashMap2.put(fst.getStart(), path);
linkedList.add(fst.getStart());
string[] osyms = fst.getOsyms();
while (!linkedList.isEmpty())
{
State state = (State)linkedList.remove();
Path path2 = (Path)hashMap2.get(state);
if (state.getFinalWeight() != semiring.zero())
{
string text2 = path2.getPath().toString();
if (hashMap.containsKey(text2))
{
Path path3 = (Path)hashMap.get(text2);
if (path3.getCost() > path2.getCost())
{
hashMap.put(text2, path2);
}
}
else
{
hashMap.put(text2, path2);
}
}
int i = state.getNumArcs();
for (int j = 0; j < i; j++)
{
Arc arc = state.getArc(j);
path = new Path(fst.getSemiring());
Path path4 = (Path)hashMap2.get(state);
path.setCost(path4.getCost());
path.setPath((ArrayList)path4.getPath().clone());
string text3 = osyms[arc.getOlabel()];
foreach (string text4 in String.instancehelper_split(text3, new StringBuilder().append("\\").append(text).toString()))
{
if (!hashSet.contains(text4))
{
path.getPath().add(text4);
}
}
path.setCost(semiring.times(path.getCost(), arc.getWeight()));
State nextState = arc.getNextState();
hashMap2.put(nextState, path);
if (!linkedList.contains(nextState))
{
linkedList.add(nextState);
}
}
}
ArrayList arrayList = new ArrayList();
Iterator iterator = hashMap.values().iterator();
while (iterator.hasNext())
{
Path path5 = (Path)iterator.next();
arrayList.add(path5);
}
Collections.sort(arrayList, new PathComparator());
int num2 = arrayList.size();
for (int i = num; i < num2; i++)
{
arrayList.remove(arrayList.size() - 1);
}
return(arrayList);
}
public static Fst compose(Fst fst1, Fst fst2, Semiring semiring, bool sorted)
{
if (!Arrays.equals(fst1.getOsyms(), fst2.getIsyms()))
{
return(null);
}
Fst fst3 = new Fst(semiring);
HashMap hashMap = new HashMap();
LinkedList linkedList = new LinkedList();
State state = fst1.getStart();
State state2 = fst2.getStart();
if (state == null || state2 == null)
{
java.lang.System.err.println("Cannot find initial state.");
return(null);
}
Pair pair = new Pair(state, state2);
State state3 = new State(semiring.times(state.getFinalWeight(), state2.getFinalWeight()));
fst3.addState(state3);
fst3.setStart(state3);
hashMap.put(pair, state3);
linkedList.add(pair);
while (!linkedList.isEmpty())
{
pair = (Pair)linkedList.remove();
state = (State)pair.getLeft();
state2 = (State)pair.getRight();
state3 = (State)hashMap.get(pair);
int numArcs = state.getNumArcs();
int numArcs2 = state2.getNumArcs();
for (int i = 0; i < numArcs; i++)
{
Arc arc = state.getArc(i);
for (int j = 0; j < numArcs2; j++)
{
Arc arc2 = state2.getArc(j);
if (sorted && arc.getOlabel() < arc2.getIlabel())
{
break;
}
if (arc.getOlabel() == arc2.getIlabel())
{
State nextState = arc.getNextState();
State nextState2 = arc2.getNextState();
Pair pair2 = new Pair(nextState, nextState2);
State state4 = (State)hashMap.get(pair2);
if (state4 == null)
{
state4 = new State(semiring.times(nextState.getFinalWeight(), nextState2.getFinalWeight()));
fst3.addState(state4);
hashMap.put(pair2, state4);
linkedList.add(pair2);
}
Arc arc3 = new Arc(arc.getIlabel(), arc2.getOlabel(), semiring.times(arc.getWeight(), arc2.getWeight()), state4);
state3.addArc(arc3);
}
}
}
}
fst3.setIsyms(fst1.getIsyms());
fst3.setOsyms(fst2.getOsyms());
return(fst3);
}
public static Fst get(Fst fst)
{
if (fst == null)
{
return(null);
}
if (fst.getSemiring() == null)
{
return(null);
}
Semiring semiring = fst.getSemiring();
Fst fst2 = new Fst(semiring);
HashMap[] array = new HashMap[fst.getNumStates()];
State[] array2 = new State[fst.getNumStates()];
State[] array3 = new State[fst.getNumStates()];
int numStates = fst.getNumStates();
for (int i = 0; i < numStates; i++)
{
State state = fst.getState(i);
State state2 = new State(state.getFinalWeight());
fst2.addState(state2);
array2[state.getId()] = state2;
array3[state2.getId()] = state;
if (state2.getId() == fst.getStart().getId())
{
fst2.setStart(state2);
}
}
for (int i = 0; i < numStates; i++)
{
State state = fst.getState(i);
State state2 = array2[state.getId()];
int numArcs = state.getNumArcs();
for (int j = 0; j < numArcs; j++)
{
Arc arc = state.getArc(j);
if (arc.getIlabel() != 0 || arc.getOlabel() != 0)
{
state2.addArc(new Arc(arc.getIlabel(), arc.getOlabel(), arc.getWeight(), array2[arc.getNextState().getId()]));
}
}
if (array[state.getId()] == null)
{
RmEpsilon.calcClosure(fst, state, array, semiring);
}
}
numStates = fst2.getNumStates();
for (int i = 0; i < numStates; i++)
{
State state = fst2.getState(i);
State state2 = array3[state.getId()];
if (array[state2.getId()] != null)
{
Iterator iterator = array[state2.getId()].keySet().iterator();
while (iterator.hasNext())
{
State state3 = (State)iterator.next();
State state4 = state3;
if (state4.getFinalWeight() != semiring.zero())
{
state.setFinalWeight(semiring.plus(state.getFinalWeight(), semiring.times(RmEpsilon.getPathWeight(state2, state4, array).floatValue(), state4.getFinalWeight())));
}
int numArcs2 = state4.getNumArcs();
for (int k = 0; k < numArcs2; k++)
{
Arc arc2 = state4.getArc(k);
if (arc2.getIlabel() != 0 || arc2.getOlabel() != 0)
{
Arc arc3 = new Arc(arc2.getIlabel(), arc2.getOlabel(), semiring.times(arc2.getWeight(), RmEpsilon.getPathWeight(state2, state4, array).floatValue()), array2[arc2.getNextState().getId()]);
state.addArc(arc3);
}
}
}
}
}
fst2.setIsyms(fst.getIsyms());
fst2.setOsyms(fst.getOsyms());
Connect.apply(fst2);
return(fst2);
}
private static void add(State state, State state2, float num, HashMap[] array, Semiring semiring)
{
Float pathWeight = RmEpsilon.getPathWeight(state, state2, array);
if (pathWeight == null)
{
RmEpsilon.put(state, state2, num, array);
}
else
{
RmEpsilon.put(state, state2, semiring.plus(num, pathWeight.floatValue()), array);
}
}
