private void closeRulesUnderMax(UnaryRule ur) { for (int i = 0, isz = closedRulesWithChild[ur.parent].size(); i < isz; i++) { UnaryRule pr = closedRulesWithChild[ur.parent].get(i); for (int j = 0, jsz = closedRulesWithParent[ur.child].size(); j < jsz; j++) { UnaryRule cr = closedRulesWithParent[ur.child].get(j); UnaryRule resultR = new UnaryRule(pr.parent, cr.child, pr.score + cr.score + ur.score); relaxRule(resultR); /* ----- No longer need to maintain unary rule backpointers if (relaxRule(resultR)) { if (resultR.parent != ur.parent) { backTrace.put(resultR, new Integer(ur.parent)); } else { backTrace.put(resultR, new Integer(ur.child)); } } -------- */ } } }
/** Create all the array variables, and put in A -> A UnaryRules to feed * the closure algorithm. They then get deleted later. */ @SuppressWarnings("unchecked") private void init() { int numStates = index.size(); coreRules = Generics.newHashMap(); rulesWithParent = new List[numStates]; rulesWithChild = new List[numStates]; closedRulesWithParent = new List[numStates]; closedRulesWithChild = new List[numStates]; bestRulesUnderMax = Generics.newHashMap(); // backTrace = Generics.newHashMap(); for (int s = 0; s < numStates; s++) { rulesWithParent[s] = new ArrayList<>(); rulesWithChild[s] = new ArrayList<>(); closedRulesWithParent[s] = new ArrayList<>(); closedRulesWithChild[s] = new ArrayList<>(); UnaryRule selfR = new UnaryRule(s, s, 0.0); relaxRule(selfR); } }
private void closeRulesUnderMax(UnaryRule ur) { for (int i = 0, isz = closedRulesWithChild[ur.parent].size(); i < isz; i++) { UnaryRule pr = closedRulesWithChild[ur.parent].get(i); for (int j = 0, jsz = closedRulesWithParent[ur.child].size(); j < jsz; j++) { UnaryRule cr = closedRulesWithParent[ur.child].get(j); UnaryRule resultR = new UnaryRule(pr.parent, cr.child, pr.score + cr.score + ur.score); relaxRule(resultR); /* ----- No longer need to maintain unary rule backpointers if (relaxRule(resultR)) { if (resultR.parent != ur.parent) { backTrace.put(resultR, new Integer(ur.parent)); } else { backTrace.put(resultR, new Integer(ur.child)); } } -------- */ } } }
private void closeRulesUnderMax(UnaryRule ur) { for (int i = 0, isz = closedRulesWithChild[ur.parent].size(); i < isz; i++) { UnaryRule pr = closedRulesWithChild[ur.parent].get(i); for (int j = 0, jsz = closedRulesWithParent[ur.child].size(); j < jsz; j++) { UnaryRule cr = closedRulesWithParent[ur.child].get(j); UnaryRule resultR = new UnaryRule(pr.parent, cr.child, pr.score + cr.score + ur.score); relaxRule(resultR); /* ----- No longer need to maintain unary rule backpointers if (relaxRule(resultR)) { if (resultR.parent != ur.parent) { backTrace.put(resultR, new Integer(ur.parent)); } else { backTrace.put(resultR, new Integer(ur.child)); } } -------- */ } } }
private void closeRulesUnderMax(UnaryRule ur) { for (int i = 0, isz = closedRulesWithChild[ur.parent].size(); i < isz; i++) { UnaryRule pr = closedRulesWithChild[ur.parent].get(i); for (int j = 0, jsz = closedRulesWithParent[ur.child].size(); j < jsz; j++) { UnaryRule cr = closedRulesWithParent[ur.child].get(j); UnaryRule resultR = new UnaryRule(pr.parent, cr.child, pr.score + cr.score + ur.score); relaxRule(resultR); /* ----- No longer need to maintain unary rule backpointers if (relaxRule(resultR)) { if (resultR.parent != ur.parent) { backTrace.put(resultR, new Integer(ur.parent)); } else { backTrace.put(resultR, new Integer(ur.child)); } } -------- */ } } }
private void closeRulesUnderMax(UnaryRule ur) { for (int i = 0, isz = closedRulesWithChild[ur.parent].size(); i < isz; i++) { UnaryRule pr = closedRulesWithChild[ur.parent].get(i); for (int j = 0, jsz = closedRulesWithParent[ur.child].size(); j < jsz; j++) { UnaryRule cr = closedRulesWithParent[ur.child].get(j); UnaryRule resultR = new UnaryRule(pr.parent, cr.child, pr.score + cr.score + ur.score); relaxRule(resultR); /* ----- No longer need to maintain unary rule backpointers if (relaxRule(resultR)) { if (resultR.parent != ur.parent) { backTrace.put(resultR, new Integer(ur.parent)); } else { backTrace.put(resultR, new Integer(ur.child)); } } -------- */ } } }
/** Create all the array variables, and put in A -> A UnaryRules to feed * the closure algorithm. They then get deleted later. */ @SuppressWarnings("unchecked") private void init() { coreRules = new HashMap<UnaryRule,UnaryRule>(); rulesWithParent = new List[numStates]; rulesWithChild = new List[numStates]; closedRulesWithParent = new List[numStates]; closedRulesWithChild = new List[numStates]; bestRulesUnderMax = new HashMap<UnaryRule,UnaryRule>(); // backTrace = new HashMap<UnaryRule,Integer>(); for (int s = 0; s < numStates; s++) { rulesWithParent[s] = new ArrayList<UnaryRule>(); rulesWithChild[s] = new ArrayList<UnaryRule>(); closedRulesWithParent[s] = new ArrayList<UnaryRule>(); closedRulesWithChild[s] = new ArrayList<UnaryRule>(); UnaryRule selfR = new UnaryRule(s, s, 0.0); relaxRule(selfR); } }
/** Create all the array variables, and put in A -> A UnaryRules to feed * the closure algorithm. They then get deleted later. */ @SuppressWarnings("unchecked") private void init() { int numStates = index.size(); coreRules = Generics.newHashMap(); rulesWithParent = new List[numStates]; rulesWithChild = new List[numStates]; closedRulesWithParent = new List[numStates]; closedRulesWithChild = new List[numStates]; bestRulesUnderMax = Generics.newHashMap(); // backTrace = Generics.newHashMap(); for (int s = 0; s < numStates; s++) { rulesWithParent[s] = new ArrayList<>(); rulesWithChild[s] = new ArrayList<>(); closedRulesWithParent[s] = new ArrayList<>(); closedRulesWithChild[s] = new ArrayList<>(); UnaryRule selfR = new UnaryRule(s, s, 0.0); relaxRule(selfR); } }
/** Create all the array variables, and put in A -> A UnaryRules to feed * the closure algorithm. They then get deleted later. */ @SuppressWarnings("unchecked") private void init() { int numStates = index.size(); coreRules = Generics.newHashMap(); rulesWithParent = new List[numStates]; rulesWithChild = new List[numStates]; closedRulesWithParent = new List[numStates]; closedRulesWithChild = new List[numStates]; bestRulesUnderMax = Generics.newHashMap(); // backTrace = Generics.newHashMap(); for (int s = 0; s < numStates; s++) { rulesWithParent[s] = new ArrayList<UnaryRule>(); rulesWithChild[s] = new ArrayList<UnaryRule>(); closedRulesWithParent[s] = new ArrayList<UnaryRule>(); closedRulesWithChild[s] = new ArrayList<UnaryRule>(); UnaryRule selfR = new UnaryRule(s, s, 0.0); relaxRule(selfR); } }
/** Create all the array variables, and put in A -> A UnaryRules to feed * the closure algorithm. They then get deleted later. */ @SuppressWarnings("unchecked") private void init() { int numStates = index.size(); coreRules = Generics.newHashMap(); rulesWithParent = new List[numStates]; rulesWithChild = new List[numStates]; closedRulesWithParent = new List[numStates]; closedRulesWithChild = new List[numStates]; bestRulesUnderMax = Generics.newHashMap(); // backTrace = Generics.newHashMap(); for (int s = 0; s < numStates; s++) { rulesWithParent[s] = new ArrayList<>(); rulesWithChild[s] = new ArrayList<>(); closedRulesWithParent[s] = new ArrayList<>(); closedRulesWithChild[s] = new ArrayList<>(); UnaryRule selfR = new UnaryRule(s, s, 0.0); relaxRule(selfR); } }