akerbladkernel.java

A Java port of LDC s Champollion sentence aligner (http://champollion.sourceforge.net). Intended aud

	    } else if (si == 0 && sj == 1) { // 0-1
		dp.rAlign.add("omitted <=> " + j);
	    } else if (si == 2 && sj == 1) { // 2-1
		dp.rAlign.add(im1 + "," + i + " <=> " + j);
	    } else if (si == 1 && sj == 2) { // 1-2
		dp.rAlign.add(i + " <=> " + jm1 + "," + j);
	    } else if (si == 2 && sj == 2) { // 2-2
		dp.rAlign.add(im1 + "," + i + " <=> " + jm1 + "," + j);
	    } else if (si == 1 && sj == 3) { // 1-3
		dp.rAlign.add(i + " <=> " + jm2 + "," + jm1 + "," + j);
	    } else if (si == 3 && sj == 1) { // 3-1
		dp.rAlign.add(im2 + "," + im1 + "," + i + " <=> " + j);
	    } else if (si == 2 && sj == 3) { // 2-3
		dp.rAlign.add(im1 + "," + i + " <=> " + jm2 + "," + jm1 + "," + j);
	    } else if (si == 3 && sj == 2) { // 3-2
		dp.rAlign.add(im2 + "," + im1 + "," + i + " <=> " + jm1 + "," + j);
		// } else if (si == 3 && sj == 3) { // 3-3
		// dp.rAlign.add("im2,im1,i <=> jm2,jm1,j";
	    } else if (si == 1 && sj == 4) { // 1-4
		dp.rAlign.add(i + " <=> " + jm3 + "," + jm2 + "," + jm1 + "," + j);
	    } else if (si == 4 && sj == 1) { // 4-1
		dp.rAlign.add(im3 + "," + im2 + "," + im1 + "," + i + " <=> " + j);
	    }
	}

	return n;
    }

    private double matchSentences(int[] x, int y[]) {
	double score;
	int nx, ny, xLen, yLen;
	double lengthPenalty = 1.0;

	// String[] tokens = StringUtils.tokenize(map, "-");
	// x = StringUtils.toIntArray(StringUtils.tokenize(tokens[0]));
	// y = StringUtils.toIntArray(StringUtils.tokenize(tokens[1]));
	// System.err.println("--- " + StringUtils.untokenize(x, " ") + " - "
//		+ StringUtils.untokenize(y, " ") + " ---");

	nx = x.length;
	ny = y.length;

	// System.err.println("FS: -0.01");
	if (nx == 0 || ny == 0)
	    return -0.1;

	// faster implementation
	if (config.fast) {
	    throw new Error("Unsupported");
	    // if (nx == 1 && ny == 1) {
	    // score = score11(x, y);
	    // } else if (nx == 1 && ny == 2) {
	    // score = score12(x, y);
	    // } else if (nx == 2 && ny == 1) {
	    // score = score12(x, y);
	    // } else if (nx == 2 && ny == 2) {
	    // score = score12(x, y);
	    // } else if (nx == 1 && ny == 3) {
	    // score = score13(x, y);
	    // } else if (nx == 3 && ny == 1) {
	    // score = score31(x, y);
	    // } else if (nx == 2 && ny == 3) {
	    // score = score23(x, y);
	    // } else if (nx == 3 && ny == 2) {
	    // score = score32(x, y);
	    // } else if (nx == 3 && ny == 3) {
	    // score = score33(x, y);
	    // } else if (nx == 1 && ny == 4) {
	    // score = score14(x, y);
	    // } else if (nx == 4 && ny == 1) {
	    // score = score41(x, y);
	    // }

	    // slower implementation
	} else {
	    String xSentences = mergeSentences(dp.xst.toArray(new String[dp.xst.size()]), x);
	    String ySentences = mergeSentences(dp.yst.toArray(new String[dp.xst.size()]), y);
	    score = matchSentencesLex(x, y, xSentences, ySentences, dp.xTokenStat);
	}

	xLen = 0;
	for (final int s : x) {
//	    System.err.println("lx: " + s + " " + dp.lenx.get(s));
	    xLen += dp.lenx.get(s);
	}

	yLen = 0;
	for (final int s : y) {
//	    System.err.println("ly: " + s + " " + dp.leny.get(s));
	    yLen += dp.leny.get(s);
	}

	if (Math.max(xLen, yLen / config.xtoyc) > 60) {
	    lengthPenalty = Math.log(6 + 4 * Math.min(xLen * config.xtoyc, yLen)
		    / Math.max(xLen * config.xtoyc, yLen))
		    / Math.log(10);
//	    System.err.println("xtoyc: " + config.xtoyc);
//	    System.err.println("ylen: " + yLen);
//	    System.err.println("xlen: " + xLen);
//	    System.err.println("lenpen: " + lengthPenalty);
	}

	if (nx == 1 && ny == 1) {
	    return score * lengthPenalty;
	} else if (nx == 1 && ny == 2) {
	    return score * lengthPenalty * penalty12;
	} else if (nx == 2 && ny == 1) {
	    return score * lengthPenalty * penalty21;
	} else if (nx == 2 && ny == 2) {
	    return score * lengthPenalty * penalty22;
	} else if (nx == 1 && ny == 3) {
	    return score * lengthPenalty * penalty13;
	} else if (nx == 3 && ny == 1) {
	    return score * lengthPenalty * penalty31;
	} else if (nx == 2 && ny == 3) {
	    return score * lengthPenalty * penalty23;
	} else if (nx == 3 && ny == 2) {
	    return score * lengthPenalty * penalty32;
	} else if (nx == 3 && ny == 3) {
	    return score * lengthPenalty * penalty33;
	} else if (nx == 1 && ny == 4) {
	    return score * lengthPenalty * penalty14;
	} else if (nx == 4 && ny == 1) {
	    return score * lengthPenalty * penalty41;
	} else {
	    throw new Error("Unexpected case.");
	}
    }

    private double matchSentencesLex(int[] xSntsIndex, int[] ySntsIndex, String xSentencesRef,
	    String ySentencesRef, HashMap<String, Integer> xTokenStatHref) {
	HashMap<String, Integer> xTokens = new HashMap<String, Integer>();
	HashMap<String, Integer> yTokens = new HashMap<String, Integer>();
	int minPairs = 1;
	double score = 0;

	for (final String s : StringUtils.tokenize(xSentencesRef)) {
	    Integer i = xTokens.get(s);
	    if (i == null)
		xTokens.put(s, 1);
	    else
		xTokens.put(s, i + 1);
	}

	for (final String s : StringUtils.tokenize(ySentencesRef)) {
	    Integer i = yTokens.get(s);
	    if (i == null)
		yTokens.put(s, 1);
	    else
		yTokens.put(s, i + 1);
	}

	// System.err.println("score bag words");

	int xTotalTokens = xTokenStatHref.get("TTAALL");

	// System.err.println("\n\n" + StringUtils.untokenize(xSntsIndex, " ") + " - "
	//	+ StringUtils.untokenize(ySntsIndex, " ") + " ");
	for (final String xToken : xTokens.keySet()) {

	    if (yTokens.containsKey(xToken) && !config.xStop.contains(xToken)) {
		score += Math.log(((double) xTotalTokens / (double) xTokenStatHref.get(xToken))
			* Math.min(xTokens.get(xToken), yTokens.get(xToken)) + 1);
		double bleh = ((double) xTotalTokens / (double) xTokenStatHref.get(xToken))
		* Math.min(xTokens.get(xToken), yTokens.get(xToken)) + 1;
//		System.err.println("bleh: " + bleh);
//		System.err.println("min: " + Math.min(xTokens.get(xToken), yTokens.get(xToken)) + 1);
//		System.err.println("xtot: " + xTotalTokens);
//		System.err.println("stathref: " + xTokenStatHref.get(xToken));
		
		// System.err.println("skore_cog: " + score);
	    } else { 
		ArrayList<String> translations = config.dict.get(xToken);
		if (translations != null) {
		    for (final String xTokenTrans : translations) {
			if (yTokens.containsKey(xTokenTrans)) {
			    minPairs = Math.min(xTokens.get(xToken), yTokens.get(xTokenTrans));

			    if (minPairs == 0)
				continue;

			     // System.err.println(xToken + " " + xTokenTrans + " " + yTokens.get(xTokenTrans));
			    score += Math.log((xTotalTokens / xTokenStatHref.get(xToken))
				    * minPairs + 1);
			    
			    // System.err.println("skoreeee: " + score);
			    xTokens.put(xToken, xTokens.get(xToken) - minPairs);
			    yTokens.put(xTokenTrans, yTokens.get(xTokenTrans) - minPairs);
			    break;
			}
		    }
		}
	    }
	}

	// System.err.println("Score: " + score);
	return score;
    }

    private String mergeSentences(String[] stAref, int[] st) {
	String sentences;

	// merge one sentence
	if (st.length == 1) {
	    sentences = stAref[st[0]] + "";

	    // merge two sentences
	} else if (st.length == 2) {
	    sentences = stAref[st[0]] + " " + stAref[st[1]];

	    // merge three sentences
	} else if (st.length == 3) {
	    sentences = stAref[st[0]] + " " + stAref[st[1]] + " " + stAref[st[2]];

	    // merge four sentences
	} else if (st.length == 4) {
	    sentences = stAref[st[0]] + " " + stAref[st[1]] + " " + stAref[st[2]] + " "
		    + stAref[st[3]];
	} else {
	    throw new Error("Unexpected sentence merge length: " + st.length);
	}

	return sentences;

    }

    private double score11(int x1, int y1) {
	return stScores[x1][y1];
    }

    private double score12(int x1, int y1, int y2) {
	return stScores[x1][y1] + stScores[x1][y2];
    }

    private double score21(int x1, int x2, int y1) {
	return stScores[x1][y1] + stScores[x2][y1];
    }

    private double score22(int x1, int x2, int y1, int y2) {
	return stScores[x1][y1] + stScores[x1][y2] + stScores[x2][y1] + stScores[x2][y1];
    }

    private double score31(int x1, int x2, int x3, int y1) {
	return stScores[x1][y1] + stScores[x2][y1] + stScores[x3][y1];
    }

    private double score13(int x1, int y1, int y2, int y3) {
	return stScores[x1][y1] + stScores[x1][y2] + stScores[x1][y3];
    }

    private double score41(int x1, int x2, int x3, int x4, int y1) {
	return stScores[x1][y1] + stScores[x2][y1] + stScores[x3][y1] + stScores[x4][y1];
    }

    private double score14(int x1, int y1, int y2, int y3, int y4) {
	return stScores[x1][y1] + stScores[x1][y2] + stScores[x1][y3] + stScores[x1][y4];
    }

    private double score14() {
	return 0.0;
    }

    private double score23() {
	return 0.0;
    }

    private double score32() {
	return 0.0;
    }

    private double score33() {
	return 0.0;
    }
}