edu.berkeley.nlp.util.Lists Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of berkeleyparser Show documentation

The Berkeley parser analyzes the grammatical structure of natural language using probabilistic context-free grammars (PCFGs).

The newest version!

package edu.berkeley.nlp.util;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;

public class Lists {

	public static  ArrayList newList(T... els) {
		ArrayList l = new ArrayList(els.length);
		for (int i = 0; i < els.length; i++) {
			l.add(els[i]);
		}
		return l;
	}

	public static  List concat(List l1, List l2) {
		List l = new ArrayList(l1.size() + l2.size());
		l.addAll(l1);
		l.addAll(l2);
		return l;
	}

	public static  void reverse(List list) {
		List temp = new ArrayList(list.size());
		temp.addAll(list);
		int len = list.size();
		for (int i = 0; i < len; i++) {
			list.set(i, temp.get(len - i - 1));
		}
	}

	public static  List subList(List list, Set indices) {
		List l = new ArrayList(indices.size());
		for (int i : indices) {
			l.add(list.get(i));
		}
		return l;
	}

	public static  void set(List list, int index, T element) {
		int gap = index - list.size() + 1;
		while (gap-- > 0) {
			list.add(null);
		}
		list.set(index, element);
	}

	public static > Comparator> comparator(T example) {
		return new Comparator>() {
			public int compare(List o1, List o2) {
				for (int i = 0; i < o1.size(); i++) {
					if (i == o2.size()) return 1;
					T c1 = o1.get(i);
					T c2 = o2.get(i);
					int r = c1.compareTo(c2);
					if (r != 0) return r;
				}
				return o2.size() > o1.size() ? -1 : 0;
			}
		};
	}

	public static int min(List list) {
		int min = Integer.MAX_VALUE;
		for (int i : list) {
			if (i < min) min = i;
		}
		return min;
	}

	public static int max(List list) {
		int max = Integer.MIN_VALUE;
		for (int i : list) {
			if (i > max) max = i;
		}
		return max;
	}

	public static  List truncate(List list, int len) {
		if (len >= list.size()) return list;
		// remove reference to old list to save memory
		List newlist = new ArrayList(list.subList(0, len));
		return newlist;
	}

	public static double dotProduct(List v1, List v2) {
		double sum = 0;
		for (int i = 0; i < v1.size(); i++)
			sum += v1.get(i) * v2.get(i);
		return sum;
	}

	public static  List fromArray(T[] array) {
		List list = new ArrayList(array.length);
		for (int i=0; i curList) {
//		int[] newArray = new int[curList.size()];
//		for(int i=0; i < newArray.length; i++) {
//			newArray[i] = curList.get(i);
//		}
//		return newArray;
//	}
//
//	public static double[] toPrimitiveArray(List curList) {
//		double[] newArray = new double[curList.size()];
//		for(int i=0; i < newArray.length; i++) {
//			newArray[i] = curList.get(i);
//		}
//		return newArray;
//	}

	/**
	 * Like Python
	 */
	public static List rangeList(int i, int j) {
		List l = new ArrayList(j - i);
		for (int k = i; k < j; k++) {
			l.add(k);
		}
		return l;
	}
}