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());
}
}
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 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 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 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);
}
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, int n, bool determinize)
{
if (fst == null)
{
return(null);
}
if (fst.getSemiring() == null)
{
return(null);
}
Fst fst2 = fst;
if (determinize)
{
fst2 = Determinize.get(fst);
}
Semiring semiring = fst2.getSemiring();
Fst fst3 = new Fst(semiring);
fst3.setIsyms(fst2.getIsyms());
fst3.setOsyms(fst2.getOsyms());
float[] array = NShortestPaths.shortestDistance(fst2);
ExtendFinal.apply(fst2);
int[] array2 = new int[fst2.getNumStates()];
PriorityQueue priorityQueue = new PriorityQueue(10, new NShortestPaths_1(array, semiring));
HashMap hashMap = new HashMap(fst.getNumStates());
HashMap hashMap2 = new HashMap(fst.getNumStates());
State start = fst2.getStart();
Pair pair = new Pair(start, Float.valueOf(semiring.one()));
priorityQueue.add(pair);
hashMap.put(pair, null);
while (!priorityQueue.isEmpty())
{
Pair pair2 = (Pair)priorityQueue.remove();
State state = (State)pair2.getLeft();
Float @float = (Float)pair2.getRight();
State state2 = new State(state.getFinalWeight());
fst3.addState(state2);
hashMap2.put(pair2, state2);
if (hashMap.get(pair2) == null)
{
fst3.setStart(state2);
}
else
{
State state3 = (State)hashMap2.get(hashMap.get(pair2));
State state4 = (State)((Pair)hashMap.get(pair2)).getLeft();
for (int i = 0; i < state4.getNumArcs(); i++)
{
Arc arc = state4.getArc(i);
if (arc.getNextState().equals(state))
{
state3.addArc(new Arc(arc.getIlabel(), arc.getOlabel(), arc.getWeight(), state2));
}
}
}
Integer integer = Integer.valueOf(state.getId());
int[] array3 = array2;
int num = integer.intValue();
int[] array4 = array3;
array4[num]++;
if (array2[integer.intValue()] == n && state.getFinalWeight() != semiring.zero())
{
break;
}
if (array2[integer.intValue()] <= n)
{
for (int j = 0; j < state.getNumArcs(); j++)
{
Arc arc2 = state.getArc(j);
float num2 = semiring.times(@float.floatValue(), arc2.getWeight());
Pair pair3 = new Pair(arc2.getNextState(), Float.valueOf(num2));
hashMap.put(pair3, pair2);
priorityQueue.add(pair3);
}
}
}
return(fst3);
}