public static ICollection <T> Intersection <T>(ICollection <T> set1, ICollection <T> set2)
{
ICollection <T> intersect = Generics.NewHashSet();
foreach (T t in set1)
{
if (set2.Contains(t))
{
intersect.Add(t);
}
}
return(intersect);
}
// private to prevent instantiation
/// <summary>Returns the set cross product of s1 and s2, as <code>Pair</code>s</summary>
public static ICollection <Pair <E, F> > Cross <E, F>(ICollection <E> s1, ICollection <F> s2)
{
ICollection <Pair <E, F> > s = Generics.NewHashSet();
foreach (E o1 in s1)
{
foreach (F o2 in s2)
{
s.Add(new Pair <E, F>(o1, o2));
}
}
return(s);
}
/// <summary>Returns the difference of sets s1 and s2.</summary>
public static ICollection <E> Diff <E>(ICollection <E> s1, ICollection <E> s2)
{
ICollection <E> s = Generics.NewHashSet();
foreach (E o in s1)
{
if (!s2.Contains(o))
{
s.Add(o);
}
}
return(s);
}
public static ICollection <T> UnionAsSet <T>(params ICollection <T>[] sets)
{
ICollection <T> union = Generics.NewHashSet();
foreach (ICollection <T> set in sets)
{
foreach (T t in set)
{
union.Add(t);
}
}
return(union);
}
/// <summary>Returns the current stack as a list</summary>
public virtual IList <T> AsList()
{
IList <T> result = Generics.NewArrayList(size);
Edu.Stanford.Nlp.Util.TreeShapedStack <T> current = this;
for (int index = 0; index < size; ++index)
{
result.Add(current.data);
current = current.Pop();
}
Java.Util.Collections.Reverse(result);
return(result);
}
/// <summary>Returns the current set of unique labels, sorted by their string order.</summary>
private IList <U> SortKeys()
{
ICollection <U> labels = UniqueLabels();
if (labels.Count == 0)
{
return(Java.Util.Collections.EmptyList());
}
bool comparable = true;
foreach (U label in labels)
{
if (!(label is IComparable))
{
comparable = false;
break;
}
}
if (comparable)
{
IList <IComparable <object> > sorted = Generics.NewArrayList();
foreach (U label_1 in labels)
{
sorted.Add(ErasureUtils.UncheckedCast <IComparable <object> >(label_1));
}
sorted.Sort();
IList <U> ret = Generics.NewArrayList();
foreach (object o in sorted)
{
ret.Add(ErasureUtils.UncheckedCast <U>(o));
}
return(ret);
}
else
{
List <string> names = new List <string>();
Dictionary <string, U> lookup = new Dictionary <string, U>();
foreach (U label_1 in labels)
{
names.Add(label_1.ToString());
lookup[label_1.ToString()] = label_1;
}
names.Sort();
List <U> ret = new List <U>();
foreach (string name in names)
{
ret.Add(lookup[name]);
}
return(ret);
}
}
public virtual ICollection <K3> ThirdKeySet()
{
ICollection <K3> keys = Generics.NewHashSet();
foreach (K1 k1 in map.Keys)
{
ThreeDimensionalMap <K2, K3, K4, V> m3 = map[k1];
foreach (K2 k2 in m3.FirstKeySet())
{
Sharpen.Collections.AddAll(keys, m3.Get(k2).FirstKeySet());
}
}
return(keys);
}
public virtual ICollection <V> Values()
{
ICollection <V> allValues = Generics.NewHashSet();
foreach (K1 k1 in map.Keys)
{
ICollection <ICollection <V> > collectionOfValues = GetCollectionValuedMap(k1).Values;
foreach (ICollection <V> values in collectionOfValues)
{
Sharpen.Collections.AddAll(allValues, values);
}
}
return(allValues);
}
public static ICollection <T> UnionAsSet <T>(ICollection <T> set1, ICollection <T> set2)
{
ICollection <T> union = Generics.NewHashSet();
foreach (T t in set1)
{
union.Add(t);
}
foreach (T t_1 in set2)
{
union.Add(t_1);
}
return(union);
}
public static string GetSignature(string name, Properties properties)
{
string[] prefixes = new string[] { (name != null && !name.IsEmpty()) ? name + '.' : string.Empty };
// TODO(gabor) This is a hack, as tokenize and ssplit depend on each other so heavily
if ("tokenize".Equals(name) || "ssplit".Equals(name))
{
prefixes = new string[] { "tokenize", "ssplit" };
}
// TODO [chris 2017]: Another hack. Traditionally, we have called the cleanxml properties clean!
if ("clean".Equals(name) || "cleanxml".Equals(name))
{
prefixes = new string[] { "clean", "cleanxml" };
}
if ("mention".Equals(name))
{
prefixes = new string[] { "mention", "coref" };
}
if ("ner".Equals(name))
{
prefixes = new string[] { "ner", "sutime" };
}
Properties propertiesCopy = new Properties();
propertiesCopy.PutAll(properties);
// handle special case of implied properties (e.g. sentiment implies parse should set parse.binaryTrees = true
// TODO(jb) This is a hack: handle implied need for binary trees if sentiment annotator is present
ICollection <string> annoNames = Generics.NewHashSet(Arrays.AsList(properties.GetProperty("annotators", string.Empty).Split("[, \t]+")));
if ("parse".Equals(name) && annoNames.Contains("sentiment") && !properties.Contains("parse.binaryTrees"))
{
propertiesCopy.SetProperty("parse.binaryTrees", "true");
}
// keep track of all relevant properties for this annotator here!
StringBuilder sb = new StringBuilder();
foreach (string pname in propertiesCopy.StringPropertyNames())
{
foreach (string prefix in prefixes)
{
if (pname.StartsWith(prefix))
{
string pvalue = propertiesCopy.GetProperty(pname);
sb.Append(pname).Append(':').Append(pvalue).Append(';');
}
}
}
return(sb.ToString());
}
/// <summary>Returns a unique object o' that .equals the argument o.</summary>
/// <remarks>
/// Returns a unique object o' that .equals the argument o. If o
/// itself is returned, this is the first request for an object
/// .equals to o.
/// </remarks>
public virtual T Intern(T o)
{
lock (this)
{
WeakReference <T> @ref = map[o];
if (@ref == null)
{
@ref = Generics.NewWeakReference(o);
map[o] = @ref;
}
// else {
// log.info("Found dup for " + o);
// }
return(@ref.Get());
}
}
/// <summary>Sample k items uniformly from an Iterable of size n (without replacement).</summary>
/// <param name="items">The items from which to sample.</param>
/// <param name="n">The total number of items in the Iterable.</param>
/// <param name="k">The number of items to sample.</param>
/// <param name="random">The random number generator.</param>
/// <returns>An Iterable of k items, chosen randomly from the original n items.</returns>
public static IEnumerable <T> Sample <T>(IEnumerable <T> items, int n, int k, Random random)
{
// assemble a list of all indexes
IList <int> indexes = new List <int>();
for (int i = 0; i < n; ++i)
{
indexes.Add(i);
}
// shuffle the indexes and select the first k
Java.Util.Collections.Shuffle(indexes, random);
ICollection <int> indexSet = Generics.NewHashSet(indexes.SubList(0, k));
// filter down to only the items at the selected indexes
return(Iterables.Filter(items, new _IPredicate_614(indexSet)));
}
/// <summary>
/// Return an immutable Set containing the same elements as the specified
/// array.
/// </summary>
/// <remarks>
/// Return an immutable Set containing the same elements as the specified
/// array. Arrays with 0 or 1 elements are special cased to return the
/// efficient small sets from the Collections class.
/// </remarks>
public static ICollection <T> AsImmutableSet <T>(T[] a)
{
if (a.Length == 0)
{
return(Java.Util.Collections.EmptySet());
}
else
{
if (a.Length == 1)
{
return(Java.Util.Collections.Singleton(a[0]));
}
else
{
return(Java.Util.Collections.UnmodifiableSet(Generics.NewHashSet(Arrays.AsList(a))));
}
}
}
public virtual ICollection <K4> FourthKeySet()
{
ICollection <K4> keys = Generics.NewHashSet();
foreach (K1 k1 in map.Keys)
{
ThreeDimensionalMap <K2, K3, K4, V> m3 = map[k1];
foreach (K2 k2 in m3.FirstKeySet())
{
TwoDimensionalMap <K3, K4, V> m2 = m3.Get(k2);
foreach (K3 k3 in m2.FirstKeySet())
{
Sharpen.Collections.AddAll(keys, m2.Get(k3).Keys);
}
}
}
return(keys);
}
/// <summary>
/// Checks to make sure that all properties specified in
/// <paramref name="properties"/>
/// are known to the program by checking that each simply overrides
/// a default value.
/// </summary>
/// <param name="properties">Current properties</param>
/// <param name="defaults">Default properties which lists all known keys</param>
public static void CheckProperties(Properties properties, Properties defaults)
{
ICollection <string> names = Generics.NewHashSet();
Sharpen.Collections.AddAll(names, properties.StringPropertyNames());
foreach (string defaultName in defaults.StringPropertyNames())
{
names.Remove(defaultName);
}
if (!names.IsEmpty())
{
if (names.Count == 1)
{
throw new ArgumentException("Unknown property: " + names.GetEnumerator().Current);
}
else
{
throw new ArgumentException("Unknown properties: " + names);
}
}
}
/// <summary>Split a list into numFolds (roughly) equally sized folds.</summary>
/// <remarks>
/// Split a list into numFolds (roughly) equally sized folds. The earlier folds
/// may have one more item in them than later folds.
/// <br />
/// The lists returned are subList()s of the original list.
/// Therefore, don't try to modify the sublists, and don't modify the
/// original list while the sublists are in use.
/// </remarks>
public static IList <IList <T> > PartitionIntoFolds <T>(IList <T> values, int numFolds)
{
IList <IList <T> > folds = Generics.NewArrayList();
int numValues = values.Count;
int foldSize = numValues / numFolds;
int remainder = numValues % numFolds;
int start = 0;
int end = foldSize;
for (int foldNum = 0; foldNum < numFolds; foldNum++)
{
// if we're in the first 'remainder' folds, we get an extra item
if (foldNum < remainder)
{
end++;
}
folds.Add(values.SubList(start, end));
start = end;
end += foldSize;
}
return(folds);
}
/// <summary>Create an ArrayHeap.</summary>
/// <param name="cmp">The objects added will be ordered using the <code>Comparator</code>.</param>
public ArrayHeap(IComparator <E> cmp)
{
this.cmp = cmp;
indexToEntry = new List <ArrayHeap.HeapEntry <E> >();
objectToEntry = Generics.NewHashMap();
}
public ThreeDimensionalMap()
{
this.map = Generics.NewHashMap();
}
public OneToOneMap()
{
//------------------------------------------------------------
m_leftAsKey = Generics.NewHashMap();
m_rightAsKey = Generics.NewHashMap();
}
/// <summary>Creates a new Index.</summary>
/// <param name="capacity">Initial capacity of Index.</param>
public HashIndex(int capacity)
: base()
{
objects = new List <E>(capacity);
indexes = Generics.NewHashMap(capacity);
}
public override IDictionary <K1, V1> SetMap <K1, V1>(IDictionary <K1, V1> map)
{
map = Generics.NewHashMap();
return(map);
}
public override IDictionary <K1, V1> SetMap <K1, V1>(IDictionary <K1, V1> map, int initCapacity)
{
map = Generics.NewHashMap(initCapacity);
return(map);
}
/// <summary>Creates a new Index.</summary>
public HashIndex()
: base()
{
objects = new List <E>();
indexes = Generics.NewHashMap();
}
public virtual void Clear()
{
map = Generics.NewWeakHashMap();
}
public override IDictionary <K, V> NewMap()
{
return(Generics.NewHashMap());
}
public override ICollection <K> NewSet(ICollection <K> init)
{
return(Generics.NewHashSet(init));
}
public FourDimensionalMap()
{
this.map = Generics.NewHashMap();
}
public ArrayHeap(IComparator <E> cmp, int initCapacity)
{
this.cmp = cmp;
indexToEntry = new List <ArrayHeap.HeapEntry <E> >(initCapacity);
objectToEntry = Generics.NewHashMap(initCapacity);
}
public static ICollection <T> AsSet <T>(params T[] o)
{
return(Generics.NewHashSet(Arrays.AsList(o)));
}
public override IDictionary <K, V> NewMap(int initCapacity)
{
return(Generics.NewHashMap(initCapacity));
}