ExtendedSet (com.metamx:extendedset 1.3.10 API)

Type Parameters:
T - the type of elements maintained by this set

All Superinterfaces:

Cloneable, Collection<T>, Comparable<ExtendedSet<T>>, Iterable<T>, Set<T>, SortedSet<T>

All Known Implementing Classes:

AbstractExtendedSet, AbstractExtendedSet.ExtendedSubSet, AbstractExtendedSet.FilteredSet, AbstractExtendedSet.UnmodifiableExtendedSet, GenericExtendedSet, IndexedSet, IntegerSet, PairSet
```
public interface ExtendedSet<T>
extends SortedSet<T>, Cloneable, Comparable<ExtendedSet<T>>
```
An interface which extends SortedSet by adding intersection/union/difference and other set operations.

Version:

$Id: ExtendedSet.java 140 2011-02-07 21:30:29Z cocciasik $

Author:

Alessandro Colantonio

See Also:
AbstractExtendedSet, IndexedSet, GenericExtendedSet, ArraySet, IntegerSet, LongSet, PairSet

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`ExtendedSet.ExtendedIterator<X>` Extended version of the `Iterator` interface that allows to "skip" some elements of the set

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`bitmapCompressionRatio()` Computes the compression factor of the equivalent bitmap representation (1 means not compressed, namely a memory footprint similar to `BitSet`, 2 means twice the size of `BitSet`, etc.)
`void`	`clear(T from, T to)` Removes from the set all the elements between `first` and `last`, both included.
`ExtendedSet<T>`	`clone()` See the `clone()` of `Object`
`double`	`collectionCompressionRatio()` Computes the compression factor of the equivalent integer collection (1 means not compressed, namely a memory footprint similar to `ArrayList`, 2 means twice the size of `ArrayList`, etc.)
`int`	`compareTo(ExtendedSet<T> o)` Compares this object with the specified object for order.
`void`	`complement()` Complements the current set.
`ExtendedSet<T>`	`complemented()` Generates the complement set.
`int`	`complementSize()` Computes the complement set size.
`boolean`	`containsAny(Collection<? extends T> other)` Returns `true` if the specified `Collection` instance contains any elements that are also contained within this `ExtendedSet` instance
`boolean`	`containsAtLeast(Collection<? extends T> other, int minElements)` Returns `true` if the specified `Collection` instance contains at least `minElements` elements that are also contained within this `ExtendedSet` instance
`ExtendedSet<T>`	`convert(Collection<?> c)` Converts a given `Collection` instance into an instance of the current class.
`ExtendedSet<T>`	`convert(Object... e)` Converts a given integer array into an instance of the current class
`String`	`debugInfo()` Prints debug info about the given `ExtendedSet` implementation
`Iterable<T>`	`descending()` Allows to use the Java "for-each" statement in descending order
`ExtendedSet.ExtendedIterator<T>`	`descendingIterator()` Gets the descending order iterator over the elements of type `T`
`ExtendedSet<T>`	`difference(Collection<? extends T> other)` Generates the difference set
`int`	`differenceSize(Collection<? extends T> other)` Computes the difference set size.
`ExtendedSet<T>`	`empty()` Generates an empty set
`void`	`fill(T from, T to)` Adds to the set all the elements between `first` and `last`, both included.
`void`	`flip(T e)` Adds the element if it not existing, or removes it if existing
`T`	`get(int i)` Gets the `i`^th element of the set
`ExtendedSet<T>`	`headSet(T toElement)`
`int`	`indexOf(T e)` Provides position of element within the set.
`ExtendedSet<T>`	`intersection(Collection<? extends T> other)` Generates the intersection set
`int`	`intersectionSize(Collection<? extends T> other)` Computes the intersection set size.
`ExtendedSet.ExtendedIterator<T>`	`iterator()`
`double`	`jaccardDistance(ExtendedSet<T> other)` Computes the Jaccard distance between this set and the given set.
`double`	`jaccardSimilarity(ExtendedSet<T> other)` Computes the Jaccard similarity coefficient between this set and the given set.
`List<? extends ExtendedSet<T>>`	`powerSet()` Computes the power-set of the current set.
`List<? extends ExtendedSet<T>>`	`powerSet(int min, int max)` Computes a subset of the power-set of the current set, composed by those subsets that have cardinality between `min` and `max`.
`int`	`powerSetSize()` Computes the power-set size of the current set.
`int`	`powerSetSize(int min, int max)` Computes the power-set size of the current set, composed by those subsets that have cardinality between `min` and `max`.
`ExtendedSet<T>`	`subSet(T fromElement, T toElement)`
`ExtendedSet<T>`	`symmetricDifference(Collection<? extends T> other)` Generates the symmetric difference set
`int`	`symmetricDifferenceSize(Collection<? extends T> other)` Computes the symmetric difference set size.
`ExtendedSet<T>`	`tailSet(T fromElement)`
`ExtendedSet<T>`	`union(Collection<? extends T> other)` Generates the union set
`int`	`unionSize(Collection<? extends T> other)` Computes the union set size.
`ExtendedSet<T>`	`unmodifiable()` Gets the read-only version of the current set
`double`	`weightedJaccardDistance(ExtendedSet<T> other)` Computes the weighted version of the Jaccard distance between this set and the given set.
`double`	`weightedJaccardSimilarity(ExtendedSet<T> other)` Computes the weighted version of the Jaccard similarity coefficient between this set and the given set.

Methods inherited from interface java.util.SortedSet
comparator, first, last

Methods inherited from interface java.util.Set
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, remove, removeAll, retainAll, size, toArray, toArray

- Method Detail
  - intersection
```
ExtendedSet<T> intersection(Collection<? extends T> other)
```
    Generates the intersection set
    
    Parameters:
    other - ExtendedSet instance that represents the right operand
    
    Returns:
    the result of the operation
    See Also:
    Set.retainAll(java.util.Collection)
  - union
```
ExtendedSet<T> union(Collection<? extends T> other)
```
    Generates the union set
    
    Parameters:
    other - ExtendedSet instance that represents the right operand
    
    Returns:
    the result of the operation
    See Also:
    Set.addAll(java.util.Collection)
  - difference
```
ExtendedSet<T> difference(Collection<? extends T> other)
```
    Generates the difference set
    
    Parameters:
    other - ExtendedSet instance that represents the right operand
    
    Returns:
    the result of the operation
    See Also:
    Set.removeAll(java.util.Collection)
  - symmetricDifference
```
ExtendedSet<T> symmetricDifference(Collection<? extends T> other)
```
    Generates the symmetric difference set
    
    Parameters:
    other - ExtendedSet instance that represents the right operand
    
    Returns:
    the result of the operation
    See Also:
    flip(Object)
  - complemented
```
ExtendedSet<T> complemented()
```
    Generates the complement set. The returned set is represented by all the elements strictly less than SortedSet.last() that do not exist in the current set.
    
    Returns:
    the complement set
    See Also:
    complement()
  - complement
```
void complement()
```
    Complements the current set. The modified set is represented by all the elements strictly less than SortedSet.last() that do not exist in the current set.
    
    See Also:
    complemented()
  - containsAny
```
boolean containsAny(Collection<? extends T> other)
```
    Returns true if the specified Collection instance contains any elements that are also contained within this ExtendedSet instance
    
    Parameters:
    other - ExtendedSet to intersect with
    
    Returns:
    a boolean indicating whether this ExtendedSet intersects the specified ExtendedSet.
  - containsAtLeast
```
boolean containsAtLeast(Collection<? extends T> other,
                      int minElements)
```
    Returns true if the specified Collection instance contains at least minElements elements that are also contained within this ExtendedSet instance
    
    Parameters:
    other - Collection instance to intersect with
    minElements - minimum number of elements to be contained within this ExtendedSet instance
    
    Returns:
    a boolean indicating whether this ExtendedSet intersects the specified Collection.
    
    Throws:
    
    IllegalArgumentException - if minElements < 1
  - intersectionSize
```
int intersectionSize(Collection<? extends T> other)
```
    Computes the intersection set size.
    This is faster than calling intersection(Collection) and then Set.size()
    
    Parameters:
    other - Collection instance that represents the right operand
    
    Returns:
    the size
  - unionSize
```
int unionSize(Collection<? extends T> other)
```
    Computes the union set size.
    This is faster than calling union(Collection) and then Set.size()
    
    Parameters:
    other - Collection instance that represents the right operand
    
    Returns:
    the size
  - symmetricDifferenceSize
```
int symmetricDifferenceSize(Collection<? extends T> other)
```
    Computes the symmetric difference set size.
    This is faster than calling symmetricDifference(Collection) and then Set.size()
    
    Parameters:
    other - Collection instance that represents the right operand
    
    Returns:
    the size
  - differenceSize
```
int differenceSize(Collection<? extends T> other)
```
    Computes the difference set size.
    This is faster than calling difference(Collection) and then Set.size()
    
    Parameters:
    other - Collection instance that represents the right operand
    
    Returns:
    the size
  - complementSize
```
int complementSize()
```
    Computes the complement set size.
    This is faster than calling complemented() and then Set.size()
    
    Returns:
    the size
  - empty
```
ExtendedSet<T> empty()
```
    Generates an empty set
    
    Returns:
    the empty set
  - clone
```
ExtendedSet<T> clone()
```
    See the clone() of Object
    
    Returns:
    cloned object
  - bitmapCompressionRatio
```
double bitmapCompressionRatio()
```
    Computes the compression factor of the equivalent bitmap representation (1 means not compressed, namely a memory footprint similar to BitSet, 2 means twice the size of BitSet, etc.)
    
    Returns:
    the compression factor
  - collectionCompressionRatio
```
double collectionCompressionRatio()
```
    Computes the compression factor of the equivalent integer collection (1 means not compressed, namely a memory footprint similar to ArrayList, 2 means twice the size of ArrayList, etc.)
    
    Returns:
    the compression factor
  - iterator
```
ExtendedSet.ExtendedIterator<T> iterator()
```
    Specified by:
    
    iterator in interface Collection<T>
    
    Specified by:
    
    iterator in interface Iterable<T>
    
    Specified by:
    
    iterator in interface Set<T>
  - descendingIterator
```
ExtendedSet.ExtendedIterator<T> descendingIterator()
```
    Gets the descending order iterator over the elements of type T
    
    Returns:
    descending iterator
  - descending
```
Iterable<T> descending()
```
    Allows to use the Java "for-each" statement in descending order
    
    Returns:
    Iterable instance to iterate items in descending order
  - powerSet
```
List<? extends ExtendedSet<T>> powerSet()
```
    Computes the power-set of the current set.
    It is a particular implementation of the algorithm Apriori (see: Rakesh Agrawal, Ramakrishnan Srikant, Fast Algorithms for Mining Association Rules in Large Databases, in Proceedings of the 20^th International Conference on Very Large Data Bases, p.487-499, 1994). The returned power-set does not contain the empty set.
    The subsets composing the powerset are returned in a list that is sorted according to the lexicographical order provided by the sorted set.
    
    Returns:
    the power-set
    See Also:
    powerSet(int, int), powerSetSize()
  - powerSet
```
List<? extends ExtendedSet<T>> powerSet(int min,
                                      int max)
```
    Computes a subset of the power-set of the current set, composed by those subsets that have cardinality between min and max.
    It is a particular implementation of the algorithm Apriori (see: Rakesh Agrawal, Ramakrishnan Srikant, Fast Algorithms for Mining Association Rules in Large Databases, in Proceedings of the 20^th International Conference on Very Large Data Bases, p.487-499, 1994). The power-set does not contains the empty set.
    The subsets composing the powerset are returned in a list that is sorted according to the lexicographical order provided by the sorted set.
    
    Parameters:
    min - minimum subset size (greater than zero)
    max - maximum subset size
    
    Returns:
    the power-set
    See Also:
    powerSet(), powerSetSize(int, int)
  - powerSetSize
```
int powerSetSize()
```
    Computes the power-set size of the current set.
    The power-set does not contains the empty set.
    
    Returns:
    the power-set size
    See Also:
    powerSet()
  - powerSetSize
```
int powerSetSize(int min,
               int max)
```
    Computes the power-set size of the current set, composed by those subsets that have cardinality between min and max.
    The returned power-set does not contain the empty set.
    
    Parameters:
    min - minimum subset size (greater than zero)
    max - maximum subset size
    
    Returns:
    the power-set size
    See Also:
    powerSet(int, int)
  - debugInfo
```
String debugInfo()
```
    Prints debug info about the given ExtendedSet implementation
    
    Returns:
    a string that describes the internal representation of the instance
  - fill
```
void fill(T from,
        T to)
```
    Adds to the set all the elements between first and last, both included. It supposes that there is an ordering of the elements of type T and that the universe of all possible elements is known.
    
    Parameters:
    from - first element
    to - last element
  - clear
```
void clear(T from,
         T to)
```
    Removes from the set all the elements between first and last, both included. It supposes that there is an ordering of the elements of type T and that the universe of all possible elements is known.
    
    Parameters:
    from - first element
    to - last element
  - flip
```
void flip(T e)
```
    Adds the element if it not existing, or removes it if existing
    
    Parameters:
    e - element to flip
    See Also:
    symmetricDifference(Collection)
  - unmodifiable
```
ExtendedSet<T> unmodifiable()
```
    Gets the read-only version of the current set
    
    Returns:
    the read-only version of the current set
  - get
```
T get(int i)
```
    Gets the i^th element of the set
    
    Parameters:
    i - position of the element in the sorted set
    
    Returns:
    the i^th element of the set
    
    Throws:
    
    IndexOutOfBoundsException - if i is less than zero, or greater or equal to Set.size()
  - indexOf
```
int indexOf(T e)
```
    Provides position of element within the set.
    It returns -1 if the element does not exist within the set.
    
    Parameters:
    e - element of the set
    
    Returns:
    the element position
  - tailSet
```
ExtendedSet<T> tailSet(T fromElement)
```
    Specified by:
    
    tailSet in interface SortedSet<T>
  - headSet
```
ExtendedSet<T> headSet(T toElement)
```
    Specified by:
    
    headSet in interface SortedSet<T>
  - subSet
```
ExtendedSet<T> subSet(T fromElement,
                    T toElement)
```
    Specified by:
    
    subSet in interface SortedSet<T>
  - convert
```
ExtendedSet<T> convert(Collection<?> c)
```
    Converts a given Collection instance into an instance of the current class. NOTE: when the collection is already an instance of the current class, the method returns the collection itself.
    
    Parameters:
    c - collection to use to generate the new instance
    
    Returns:
    the converted collection
    See Also:
    convert(Object...)
  - convert
```
ExtendedSet<T> convert(Object... e)
```
    Converts a given integer array into an instance of the current class
    
    Parameters:
    e - objects to use to generate the new instance
    
    Returns:
    the converted collection
    See Also:
    convert(Collection)
  - jaccardSimilarity
```
double jaccardSimilarity(ExtendedSet<T> other)
```
    Computes the Jaccard similarity coefficient between this set and the given set.
    The coefficient is defined as |A intersection B| / |A union B|.
    
    Parameters:
    other - the other set
    
    Returns:
    the Jaccard similarity coefficient
    See Also:
    jaccardDistance(ExtendedSet)
  - jaccardDistance
```
double jaccardDistance(ExtendedSet<T> other)
```
    Computes the Jaccard distance between this set and the given set.
    The coefficient is defined as 1 - jaccardSimilarity(ExtendedSet).
    
    Parameters:
    other - the other set
    
    Returns:
    the Jaccard distance
    See Also:
    jaccardSimilarity(ExtendedSet)
  - weightedJaccardSimilarity
```
double weightedJaccardSimilarity(ExtendedSet<T> other)
```
    Computes the weighted version of the Jaccard similarity coefficient between this set and the given set.
    The coefficient is defined as sum of min(A_i, B_i) / sum of max(A_i, B_i).
    NOTE: T must be a number, namely one of Integer, Double, Float, Byte, Long, Short.
    
    Parameters:
    other - the other set
    
    Returns:
    the weighted Jaccard similarity coefficient
    
    Throws:
    
    IllegalArgumentException - if T is not a number
    See Also:
    weightedJaccardDistance(ExtendedSet)
  - weightedJaccardDistance
```
double weightedJaccardDistance(ExtendedSet<T> other)
```
    Computes the weighted version of the Jaccard distance between this set and the given set.
    The coefficient is defined as 1 - weightedJaccardSimilarity(ExtendedSet).
    NOTE: T must be a number, namely one of Integer, Double, Float, Byte, Long, Short.
    
    Parameters:
    other - the other set
    
    Returns:
    the weighted Jaccard distance
    
    Throws:
    
    IllegalArgumentException - if T is not a number
    See Also:
    weightedJaccardSimilarity(ExtendedSet)
  - compareTo
```
int compareTo(ExtendedSet<T> o)
```
    Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. An IntSet instance A is less than another IntSet instance B if B-A (that is, the elements in B that are not contained in A) contains at least one element that is greater than all the elements in A-B.
    The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception iff y.compareTo(x) throws an exception.)
    The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.
    Finally, the implementor must ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z.
    It is strongly recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)). Generally speaking, any class that implements the Comparable interface and violates this condition should clearly indicate this fact. The recommended language is "Note: this class has a natural ordering that is inconsistent with equals."
    In the foregoing description, the notation sgn(expression ) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.
    
    Specified by:
    
    compareTo in interface Comparable<ExtendedSet<T>>
    
    Parameters:
    o - the object to be compared.
    
    Returns:
    a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.
    
    Throws:
    
    ClassCastException - if the specified object's type prevents it from being compared to this object.

Interface ExtendedSet<T>

Nested Class Summary

Method Summary

Methods inherited from interface java.util.SortedSet

Methods inherited from interface java.util.Set

Method Detail

intersection

union

difference

symmetricDifference

complemented

complement

containsAny

containsAtLeast

intersectionSize

unionSize

symmetricDifferenceSize

differenceSize

complementSize

empty

clone

bitmapCompressionRatio

collectionCompressionRatio

iterator

descendingIterator

descending

powerSet

powerSet

powerSetSize

powerSetSize

debugInfo

fill

clear

flip

unmodifiable

get

indexOf

tailSet

headSet

subSet

convert

convert

jaccardSimilarity

jaccardDistance

weightedJaccardSimilarity

weightedJaccardDistance

compareTo