use of java.util.Hashtable in project lucida by claritylab.
the class ScoreCombinationFilter method apply.
/**
* Filters an array of <code>Result</code> objects.
*
* @param results results to filter
* @return filtered results
*/
public Result[] apply(Result[] results) {
// all results that pass the filter
List<Result> filtered = new ArrayList<Result>();
// sort results by their scores in descending order
results = (new ScoreSorterFilter()).apply(results);
// separate factoid answers by extractors
List<Result> factoids = new ArrayList<Result>();
Hashtable<String, Hashtable<String, Result>> allExtractors = new Hashtable<String, Hashtable<String, Result>>();
for (Result result : results) {
// only merge factoid answers
if (result.getScore() <= 0 || result.getScore() == Float.POSITIVE_INFINITY) {
filtered.add(result);
continue;
}
// make sure that answers come from a single extractor
String[] extractors = result.getExtractionTechniques();
if (extractors == null || extractors.length != 1) {
filtered.add(result);
continue;
}
String extractor = extractors[0];
factoids.add(result);
Hashtable<String, Result> sameExtractor = allExtractors.get(extractor);
if (sameExtractor == null) {
sameExtractor = new Hashtable<String, Result>();
allExtractors.put(extractor, sameExtractor);
}
String norm = StringUtils.normalize(result.getAnswer());
sameExtractor.put(norm, result);
}
// merge answers from different extractors
String[] extractors = allExtractors.keySet().toArray(new String[allExtractors.size()]);
Set<String> covered = new HashSet<String>();
for (Result result : factoids) {
String norm = StringUtils.normalize(result.getAnswer());
if (!covered.add(norm))
continue;
// get all extractors for the result and the normalized scores
ArrayList<String> exs = new ArrayList<String>();
ArrayList<Float> scores = new ArrayList<Float>();
for (String extractor : extractors) {
Result r = allExtractors.get(extractor).get(norm);
if (r != null) {
exs.add(extractor);
scores.add(r.getNormScore());
}
}
// set extractors
result.setExtractionTechniques(exs.toArray(new String[exs.size()]));
// combine their normalized scores
float[] scoresA = new float[scores.size()];
for (int i = 0; i < scoresA.length; i++) scoresA[i] = scores.get(i);
int totalExtractors = extractors.length;
float combinedScore = // combANZ(scoresA, totalExtractors);
combMNZ(scoresA, totalExtractors);
// combCP(scoresA, totalExtractors);
result.setScore(combinedScore);
result.setNormScore(combinedScore);
filtered.add(result);
}
return filtered.toArray(new Result[filtered.size()]);
}
use of java.util.Hashtable in project lucida by claritylab.
the class TruncationFilter method apply.
/**
* Filters an array of <code>Result</code> objects.
*
* @param results results to filter
* @return filtered results
*/
public Result[] apply(Result[] results) {
// all results that pass the filter
ArrayList<Result> filtered = new ArrayList<Result>();
// for each extractor, truncated answers and corresponding results
Hashtable<String, Hashtable<String, Result>> truncated = new Hashtable<String, Hashtable<String, Result>>();
// sort results by their scores in descending order
results = (new ScoreSorterFilter()).apply(results);
for (Result result : results) {
// only truncate factoid answers
if (result.getScore() <= 0 || result.getScore() == Float.POSITIVE_INFINITY) {
filtered.add(result);
continue;
}
// make sure that answers come from a single extractor
String[] extractors = result.getExtractionTechniques();
if (extractors == null || extractors.length != 1) {
filtered.add(result);
continue;
}
String extractor = extractors[0];
// truncate result
result = apply(result);
// merge with similar results from same extractor
Hashtable<String, Result> truncatedT = truncated.get(extractor);
if (truncatedT == null) {
truncatedT = new Hashtable<String, Result>();
truncated.put(extractor, truncatedT);
}
String norm = StringUtils.normalize(result.getAnswer());
Result similar = truncatedT.get(norm);
if (similar == null) {
filtered.add(result);
truncatedT.put(norm, result);
} else {
similar.incScore(result.getScore());
}
}
return filtered.toArray(new Result[filtered.size()]);
}
use of java.util.Hashtable in project lucida by claritylab.
the class ScoreNormalizationFilter method preserveOrderTop.
/**
* Calculates the normalization factor of the top answer for each extraction
* technique and normalizes the scores with this factor to ensure that the
* order suggested by the original scores is preserved.
*
* @param results array of <code>Result</code> objects
* @return array of <code>Result</code> objects with new normalized scores
*/
public Result[] preserveOrderTop(Result[] results) {
// get answers by extractors
Hashtable<String, ArrayList<Result>> allExtracted = new Hashtable<String, ArrayList<Result>>();
for (Result result : results) {
// only factoid answers with 1 extraction technique
if (result.getScore() <= 0 || result.getScore() == Float.POSITIVE_INFINITY || result.getExtractionTechniques() == null || result.getExtractionTechniques().length != 1)
continue;
String extractor = result.getExtractionTechniques()[0];
ArrayList<Result> extracted = allExtracted.get(extractor);
if (extracted == null) {
extracted = new ArrayList<Result>();
allExtracted.put(extractor, extracted);
}
extracted.add(result);
}
// normalize answer scores for each extractor
for (List<Result> extracted : allExtracted.values()) {
// get normalization factor of top answer
float maxScore = 0;
float maxNormScore = 0;
for (Result factoid : extracted) {
float score = factoid.getScore();
float normScore = factoid.getNormScore();
if (score > maxScore) {
maxScore = score;
maxNormScore = normScore;
}
}
double topNormFactor = maxNormScore / maxScore;
// normalize scores with average normalization factor
for (Result factoid : extracted) {
float norm = (float) (factoid.getScore() * topNormFactor);
factoid.setNormScore(norm);
}
}
return results;
}
use of java.util.Hashtable in project hackpad by dropbox.
the class Parser method function.
private Node function(int functionType) throws IOException, ParserException {
int syntheticType = functionType;
// line number where source starts
int baseLineno = ts.getLineno();
int functionSourceStart = decompiler.markFunctionStart(functionType);
String name;
Node memberExprNode = null;
if (matchToken(Token.NAME)) {
name = ts.getString();
decompiler.addName(name);
if (!matchToken(Token.LP)) {
if (compilerEnv.isAllowMemberExprAsFunctionName()) {
// Extension to ECMA: if 'function <name>' does not follow
// by '(', assume <name> starts memberExpr
Node memberExprHead = nf.createName(name);
name = "";
memberExprNode = memberExprTail(false, memberExprHead);
}
mustMatchToken(Token.LP, "msg.no.paren.parms");
}
} else if (matchToken(Token.LP)) {
// Anonymous function
name = "";
} else {
name = "";
if (compilerEnv.isAllowMemberExprAsFunctionName()) {
// Note that memberExpr can not start with '(' like
// in function (1+2).toString(), because 'function (' already
// processed as anonymous function
memberExprNode = memberExpr(false);
}
mustMatchToken(Token.LP, "msg.no.paren.parms");
}
if (memberExprNode != null) {
syntheticType = FunctionNode.FUNCTION_EXPRESSION;
}
boolean nested = insideFunction();
FunctionNode fnNode = nf.createFunction(name);
if (nested || nestingOfWith > 0) {
// 1. Nested functions are not affected by the dynamic scope flag
// as dynamic scope is already a parent of their scope.
// 2. Functions defined under the with statement also immune to
// this setup, in which case dynamic scope is ignored in favor
// of with object.
fnNode.itsIgnoreDynamicScope = true;
}
int functionIndex = currentScriptOrFn.addFunction(fnNode);
int functionSourceEnd;
ScriptOrFnNode savedScriptOrFn = currentScriptOrFn;
currentScriptOrFn = fnNode;
int savedNestingOfWith = nestingOfWith;
nestingOfWith = 0;
Hashtable savedLabelSet = labelSet;
labelSet = null;
ObjArray savedLoopSet = loopSet;
loopSet = null;
ObjArray savedLoopAndSwitchSet = loopAndSwitchSet;
loopAndSwitchSet = null;
boolean savedHasReturnValue = hasReturnValue;
int savedFunctionEndFlags = functionEndFlags;
Node body;
try {
decompiler.addToken(Token.LP);
if (!matchToken(Token.RP)) {
boolean first = true;
do {
if (!first)
decompiler.addToken(Token.COMMA);
first = false;
mustMatchToken(Token.NAME, "msg.no.parm");
String s = ts.getString();
if (fnNode.hasParamOrVar(s)) {
addWarning("msg.dup.parms", s);
}
fnNode.addParam(s);
decompiler.addName(s);
} while (matchToken(Token.COMMA));
mustMatchToken(Token.RP, "msg.no.paren.after.parms");
}
decompiler.addToken(Token.RP);
mustMatchToken(Token.LC, "msg.no.brace.body");
decompiler.addEOL(Token.LC);
body = parseFunctionBody();
mustMatchToken(Token.RC, "msg.no.brace.after.body");
if (compilerEnv.isStrictMode() && !body.hasConsistentReturnUsage()) {
String msg = name.length() > 0 ? "msg.no.return.value" : "msg.anon.no.return.value";
addStrictWarning(msg, name);
}
decompiler.addToken(Token.RC);
functionSourceEnd = decompiler.markFunctionEnd(functionSourceStart);
if (functionType != FunctionNode.FUNCTION_EXPRESSION) {
// Add EOL only if function is not part of expression
// since it gets SEMI + EOL from Statement in that case
decompiler.addToken(Token.EOL);
}
} finally {
hasReturnValue = savedHasReturnValue;
functionEndFlags = savedFunctionEndFlags;
loopAndSwitchSet = savedLoopAndSwitchSet;
loopSet = savedLoopSet;
labelSet = savedLabelSet;
nestingOfWith = savedNestingOfWith;
currentScriptOrFn = savedScriptOrFn;
}
fnNode.setEncodedSourceBounds(functionSourceStart, functionSourceEnd);
fnNode.setSourceName(sourceURI);
fnNode.setBaseLineno(baseLineno);
fnNode.setEndLineno(ts.getLineno());
if (name != null) {
int index = currentScriptOrFn.getParamOrVarIndex(name);
if (index >= 0 && index < currentScriptOrFn.getParamCount())
addStrictWarning("msg.var.hides.arg", name);
}
Node pn = nf.initFunction(fnNode, functionIndex, body, syntheticType);
if (memberExprNode != null) {
pn = nf.createAssignment(Token.ASSIGN, memberExprNode, pn);
if (functionType != FunctionNode.FUNCTION_EXPRESSION) {
// XXX check JScript behavior: should it be createExprStatement?
pn = nf.createExprStatementNoReturn(pn, baseLineno);
}
}
return pn;
}
use of java.util.Hashtable in project che by eclipse.
the class AssistQuickFixTest18 method setUp.
// public static Test suite() {
// return setUpTest(new TestSuite(THIS));
// }
//
// public static Test setUpTest(Test test) {
// return new Java18ProjectTestSetup(test);
// }
@Before
public void setUp() throws Exception {
super.setUp();
Hashtable options = TestOptions.getDefaultOptions();
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
JavaCore.setOptions(options);
IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
store.setValue(PreferenceConstants.CODEGEN_ADD_COMMENTS, false);
StubUtility.setCodeTemplate(CodeTemplateContextType.METHODSTUB_ID, "//TODO\n${body_statement}", null);
fJProject1 = Java18ProjectTestSetup.getProject();
fSourceFolder = JavaProjectHelper.addSourceContainer(fJProject1, "src");
}
Aggregations