akerblad.java

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

    // if (pxtkn/pytkn > nxtkn/nytkn) {
    // align_org[i-1] .= ",ysid";
    // } else {
    // align_org[i+1] =~ s/<=> /<=> ysid,/;
    // }
    // align_org[i] = "";
    // }
    // } elsif (align_org[i] =~ /(\d+) <=> omitted/) {
    // xsid = 1;
    // lb = lowerbound(xsid, \%x2ymap);
    // ub = upperbound(xsid, \%x2ymap);
    // next unless defined ub && defined lb;
    // if (ub-lb == 1) {
    // my (pxtkn, pytkn, nxtkn, nytkn) = (0,0,0,0);
    //    		
    // # counting tokens of previous alignment
    // align_org[i-1] =~ /(.+) <=> (.+)/;
    // xsent = 1; ysent = 2;
    // @xsent = split /,/, xsent;
    // @ysent = split /,/, ysent;
    // foreach (@xsent) {
    // pxtkn += lenx[_-1];
    // }
    // foreach (@ysent) {
    // pytkn += leny[_-1];
    // }
    //
    // # counting tokens of next alignment
    // align_org[i+1] =~ /(.+) <=> (.+)/;
    // xsent = 1; ysent = 2;
    // @xsent = split /,/, xsent;
    // @ysent = split /,/, ysent;
    // foreach (@xsent) {
    // nxtkn += lenx[_-1];
    // }
    // foreach (@ysent) {
    // nytkn += leny[_-1];
    // }
    //
    // if (pxtkn/pytkn < nxtkn/nytkn) {
    // align_org[i-1] =~ s/ <=>/,xsid <=>/;
    // } else {
    // align_org[i+1] = xsid.",".align_org[i+1];
    // }
    // align_org[i] = "";
    // }
    // }
    // }
    // undef @rAlign;
    // foreach (@align_org) {
    // push @rAlign, _ unless /^/;
    // }
    //        
    // @rAlign = reverse @rAlign;
    //        
    // }

    private void printAlignment(DocPair dp, String alignmentFile) throws FileNotFoundException {
	PrintWriter out = new PrintWriter(alignmentFile);

	for (int i = dp.rAlign.size() - 1; i >= 0; i--) {
	    out.println(dp.rAlign.get(i));
	}
	out.close();
    }

    // private String lowerbound(int sid, Map mapref) {
    // int psid = sid - 1;
    // Map map = mapref.get(psid);
    // if (map != null) {
    // return map[map.size() - 1];
    // } else {
    // return null;
    // }
    // }

    // private String upperbound(int sid, Map mapref) {
    // int nsid = sid + 1;
    // Map map = mapref.get(nsid);
    // if (map != null) {
    // return map[0];
    // } else {ubuntu console music player
    // return null;
    // }
    // }

    private static void usage() {
	System.err.println("usage: 0 [-hdscn] <X token file> <Y token file> <alignment file>\n\n\n"
		+ "-h       : this (help) message\n"
		+ "-d dictf : use dictf as the translation dictionary\n"
		+ "-s xstop : use words in file xstop as X stop words\n"
		+ "-c n     : number of Y chars for each X char\n"
		+ "-n       : disallow 1-3, 3-1, 1-4, 4-1 alignments\n"
		+ "-e       : emulate champollion as closely as possible (not recommended)\n"
		+ "-l       : use last 3 arguments as newline separated lists of input files\n"
		+ "           (saves time of reloading dict & stopwords)");
//		+ "(faster, lower performance)\n");

	System.exit(1);
    }

//    private boolean inWindow(DocPair dp, int xsnt, int ysnt) {
//	int center = (int) (ysnt * dp.xyRatio);
//	int windowStart = center - dp.windowSize > 0 ? center - dp.windowSize : 0;
//	int windowEnd = center + dp.windowSize < dp.nx ? center + dp.windowSize : dp.nx;
//
//	if (xsnt >= windowStart && xsnt <= windowEnd) {
//	    return true;
//	} else {
//	    return false;
//	}
//    }

    // private void findTransPairs(DocPair dp) {
    // int entry = 0;
    // boolean found = false;
    // ArrayList<String> dictIdx = new ArrayList<String>();
    //
    // for (final String xToken : dp.xTkn2snt.keySet()) {
    // log.fine("XT: " + xToken);
    // found = false;
    // if (config.xStop.contains(xToken))
    // continue;
    //
    // for (final int ysnt : dp.yTkn2snt.get(xToken)) {
    // for (final int xsnt : dp.xTkn2snt.get(xToken)) {
    // if (inWindow(dp, xsnt, ysnt)) {
    // transPairs.get(new IntPair(xsnt, ysnt)).put(entry);
    // found = true;
    // }
    // }
    // }
    //
    // if (found) {
    // dictIdx.add(xToken + " " + xToken);
    // log.fine("DICT entry: " + dictIdx.get(entry - 1));
    // }
    //
    // for (final String xTokenTrans : config.dict.get(xToken)) {
    // found = false;
    // log.fine("XTT: " + xTokenTrans);
    // for (final int ysnt : dp.xTkn2snt.get(xTokenTrans)) {
    // log.fine(ysnt + "");
    // for (final int xsnt : dp.xTkn2snt.get(xToken)) {
    // if (inWindow(dp, xsnt, ysnt)) {
    // transPairs.get(new IntPair(xsnt, ysnt)).put(entry);
    // found = true;
    // log.fine(xsnt + " " + ysnt + " " + xToken + " " + xTokenTrans);
    // }
    // }
    // }
    // if (found) {
    // dictIdx.add(xToken + " " + xTokenTrans);
    // log.fine("DICT entry: " + dictIdx.get(entry - 1));
    // }
    // }
    // }
    // }

    // private void findTransPairsCn(DocPair dp) {
    // int entry = 0;
    // Set<Integer> ystno;
    // boolean found = false;
    // ArrayList<String> dictIdx = new ArrayList<String>();
    //
    // TreeSet<String> sortedSet = new TreeSet<String>(dp.xTkn2snt.keySet());
    // for (final String xToken : sortedSet) {
    // log.fine("XT: " + xToken);
    // found = false;
    //
    // if (config.xStop.contains(xToken)) {
    // continue;
    // }
    //
    // ystno = cnIndex(dp, xToken);
    // log.fine(StringUtils.untokenize(ystno));
    //
    // for (final int ysnt : ystno) {
    // for (final int xsnt : dp.yTkn2snt.get(xToken)) {
    // if (inWindow(dp, xsnt, ysnt)) {
    // // yst[ysnt]=~/\bxtoken\b/
    // throw new Error();
    // if (false/* MATCH REGEX */) {
    // transPairs.get(new IntPair(xsnt, ysnt)).put(entry);
    // found = true;
    // }
    // }
    // }
    // }
    //
    // if (found) {
    // dictIdx.add(xToken + " " + xToken);
    // log.fine("DICT entry: " + dictIdx.get(entry - 1));
    // }
    //
    // for (final String xTokenTrans : config.dict.get(xToken)) {
    // found = false;
    // log.fine("XTT: " + xTokenTrans);
    // ystno = cnIndex(dp, xTokenTrans);
    // log.fine(StringUtils.untokenize(ystno));
    //
    // for (final int ysnt : ystno) {
    // log.fine(ysnt + "");
    // for (final int xsnt : dp.xTkn2snt.get(xToken)) {
    // if (inWindow(dp, xsnt, ysnt)) {
    //
    // // yst[ysnt]=~/xtoken_trans/
    // throw new Error();
    // if (false/* MATCH REGEX */)
    // transPairs.get(new IntPair(xsnt, ysnt)).put(entry);
    // found = true;
    // log.fine(xsnt + " " + ysnt + " " + xToken + " " + xTokenTrans);
    // }
    // }
    // }
    // if (found) {
    // dictIdx.add(xToken + " " + xTokenTrans);
    // log.fine("DICT entry: " + dictIdx.get(entry - 1));
    // }
    // }
    // }
    // }

    // private Set<Integer> cnIndex(DocPair dp, String string) {
    // HashSet<Integer> snt;
    // char[] charr;
    // HashMap<Character, Integer> seen;
    // HashSet<Integer> neww;
    // ArrayList<Character> uniqChar = new ArrayList<Character>();
    //
    // log.fine(string);
    // log.fine(StringUtils.untokenize(uniqChar));
    // // string =~ s/\\(.)/1/g;
    // // XXX: What is the purpose of this regex?
    // if (string.contains("\\")) {
    // StringBuilder builder = new StringBuilder();
    // int nPrev = 0;
    // int n;
    // while (nPrev < string.length() && (n = string.indexOf('\\', nPrev)) !=
    // -1) {
    // builder.append(string.substring(nPrev, n));
    // nPrev = n + 2;
    // }
    // string = builder.toString();
    // }
    //
    // charr = string.toCharArray();
    //
    // seen = new HashMap<Character, Integer>();
    // for (final char item : charr) {
    // Integer i = seen.get(item);
    // if (i == null) {
    // seen.put(item, 0);
    // uniqChar.add(item);
    // } else {
    // seen.put(item, i + 1);
    // }
    // }
    //
    // log.fine(StringUtils.untokenize(uniqChar));
    // snt = dp.yTkn2snt.get(uniqChar.get(0));
    // log.fine(uniqChar.get(0) + " " + StringUtils.untokenize(snt));
    // for (int i = 1; i < uniqChar.size(); i++) {
    // neww = dp.yTkn2snt.get(uniqChar.get(i));
    //
    // for (final Integer key : snt) {
    // if (!neww.contains(key))
    // snt.remove(key);
    // }
    // if (snt.size() == 0)
    // return snt;
    // }
    //
    // return snt;
    // }
}