PairSet (com.metamx:extendedset 1.3.10 API)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractSet<T>
 - - it.uniroma3.mat.extendedset.AbstractExtendedSet<Pair<T,I>>
 - - it.uniroma3.mat.extendedset.wrappers.matrix.PairSet<T,I>

All Implemented Interfaces:

ExtendedSet<Pair<T,I>>, Serializable, Cloneable, Comparable<ExtendedSet<Pair<T,I>>>, Iterable<Pair<T,I>>, Collection<Pair<T,I>>, Set<Pair<T,I>>, SortedSet<Pair<T,I>>
```
public class PairSet<T,I>
extends AbstractExtendedSet<Pair<T,I>>
implements Serializable
```
A set of pairs internally represented by a binary matrix.
This class can be used to represent a set of transactions, where each transaction is a set of items. Rows are transactions, columns are the items involved with each transaction.

Version:

$Id: PairSet.java 153 2011-05-30 16:39:57Z cocciasik $

Author:

Alessandro Colantonio

See Also:
Pair, IntSet, Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class it.uniroma3.mat.extendedset.AbstractExtendedSet
 AbstractExtendedSet.ExtendedSubSet, AbstractExtendedSet.FilteredSet, AbstractExtendedSet.UnmodifiableExtendedSet
- Nested classes/interfaces inherited from interface it.uniroma3.mat.extendedset.ExtendedSet
 ExtendedSet.ExtendedIterator<X>

Constructor Summary

Constructors
Constructor and Description
`PairSet(BinaryMatrix matrix, Collection<? extends Pair<T,I>> pairs)` Converts a generic collection of transaction-item pairs to a `PairSet` instance.
`PairSet(BinaryMatrix matrix, Collection<T> transactions, Collection<I> items)` Initializes the set by specifying all possible transactions and items.
`PairSet(BinaryMatrix matrix, Object[][] pairs)` Initializes the set by specifying all possible transactions and items.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(Pair<T,I> e)`
`boolean`	`add(T transaction, I item)` Adds a single transaction-item pair
`boolean`	`addAll(Collection<? extends Pair<T,I>> c)`
`boolean`	`addAll(Collection<T> trans, Collection<I> items)` Add the pairs obtained from the Cartesian product of transactions and items
`boolean`	`addAll(Collection<T> trans, I item)` Add the pairs obtained from the Cartesian product of transactions and items
`boolean`	`addAll(T trans, Collection<I> items)` Add the pairs obtained from the Cartesian product of transactions and items
`IndexedSet<I>`	`allItems()` Gets the set of all possible items that can be contained within each transaction
`IndexedSet<T>`	`allTransactions()` Gets the set of all possible transactions that can be contained within the set
`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()`
`void`	`clear(Pair<T,I> from, Pair<T,I> to)` Removes from the set all the elements between `first` and `last`, both included.
`PairSet<T,I>`	`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.)
`PairSet<T,I>`	`compacted()` Creates a new `PairSet` instance with only non-empty transactions and items.
`Comparator<? super Pair<T,I>>`	`comparator()`
`int`	`compareTo(ExtendedSet<Pair<T,I>> o)` Compares this object with the specified object for order.
`void`	`complement()` Complements the current set.
`PairSet<T,I>`	`complemented()` Generates the complement set.
`int`	`complementSize()` Computes the complement set size.
`boolean`	`contains(Object o)`
`boolean`	`contains(T transaction, I item)` Checks if the given transaction-item pair is contained within the set
`boolean`	`containsAll(Collection<?> c)`
`boolean`	`containsAll(Collection<T> trans, Collection<I> items)` Checks if the pairs obtained from the Cartesian product of transactions and items are contained
`boolean`	`containsAll(Collection<T> trans, I item)` Checks if the pairs obtained from the Cartesian product of transactions and items are contained
`boolean`	`containsAll(T trans, Collection<I> items)` Checks if the pairs obtained from the Cartesian product of transactions and items are contained
`boolean`	`containsAny(Collection<? extends Pair<T,I>> other)` Returns `true` if the specified `Collection` instance contains any elements that are also contained within this `ExtendedSet` instance
`boolean`	`containsAtLeast(Collection<? extends Pair<T,I>> other, int minElements)` Returns `true` if the specified `Collection` instance contains at least `minElements` elements that are also contained within this `ExtendedSet` instance
`PairSet<T,I>`	`convert(Collection<?> c)` Converts a given `Collection` instance into an instance of the current class.
`PairSet<T,I>`	`convert(Object... e)` Converts a given integer array into an instance of the current class
`static PairSet<Integer,Integer>`	`createFromBinaryMatrix(BinaryMatrix b)` Wraps a `BinaryMatrix` instance with a `PairSet` instance.
`String`	`debugInfo()` Prints debug info about the given `ExtendedSet` implementation
`ExtendedSet.ExtendedIterator<Pair<T,I>>`	`descendingIterator()` Gets the descending order iterator over the elements of type `T`
`PairSet<T,I>`	`difference(Collection<? extends Pair<T,I>> other)` Generates the difference set
`int`	`differenceSize(Collection<? extends Pair<T,I>> other)` Computes the difference set size.
`PairSet<T,I>`	`empty()` Generates an empty set
`boolean`	`equals(Object obj)`
`void`	`fill(Pair<T,I> from, Pair<T,I> to)` Adds to the set all the elements between `first` and `last`, both included.
`Pair<T,I>`	`first()`
`void`	`flip(Pair<T,I> e)` Adds the element if it not existing, or removes it if existing
`Pair<T,I>`	`get(int index)` Gets the `i`^th element of the set
`int`	`hashCode()`
`PairSet<T,I>`	`headSet(Pair<T,I> toElement)`
`int`	`indexOf(Pair<T,I> element)` Provides position of element within the set.
`PairSet<T,I>`	`intersection(Collection<? extends Pair<T,I>> c)` Generates the intersection set
`IndexedSet<I>`	`involvedItems()` Gets the set of items in `allItems()` that are contained in at least one transaction
`IndexedSet<T>`	`involvedTransactions()` Gets the set of transactions in `allTransactions()` that contains at least one item
`boolean`	`isEmpty()`
`IndexedSet<I>`	`itemsOf(T transaction)` Lists all items contained within a given transaction
`ExtendedSet.ExtendedIterator<Pair<T,I>>`	`iterator()`
`Pair<T,I>`	`last()`
`BinaryMatrix`	`matrix()` Returns the set of indices.
`PairSet<T,I>`	`merged(PairSet<T,I> other)` Creates a new `PairSet` instance with the union of all possible transactions and items as result for `allTransactions()` and `allItems()`, respectively, and the union of pairs.
`List<? extends PairSet<T,I>>`	`powerSet()` Computes the power-set of the current set.
`List<? extends PairSet<T,I>>`	`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`.
`boolean`	`remove(Object o)`
`boolean`	`remove(T transaction, I item)` Removes a single transaction-item pair
`boolean`	`removeAll(Collection<?> c)`
`boolean`	`removeAll(Collection<T> trans, Collection<I> items)` Removes the pairs obtained from the Cartesian product of transactions and items
`boolean`	`removeAll(Collection<T> trans, I item)` Removes the pairs obtained from the Cartesian product of transactions and items
`boolean`	`removeAll(T trans, Collection<I> items)` Removes the pairs obtained from the Cartesian product of transactions and items
`boolean`	`retainAll(Collection<?> c)`
`boolean`	`retainAll(Collection<T> trans, Collection<I> items)` Retains the pairs obtained from the Cartesian product of transactions and items
`boolean`	`retainAll(Collection<T> trans, I item)` Retains the pairs obtained from the Cartesian product of transactions and items
`boolean`	`retainAll(T trans, Collection<I> items)` Retains the pairs obtained from the Cartesian product of transactions and items
`int`	`size()`
`PairSet<T,I>`	`subSet(Pair<T,I> fromElement, Pair<T,I> toElement)`
`PairSet<T,I>`	`symmetricDifference(Collection<? extends Pair<T,I>> other)` Generates the symmetric difference set
`int`	`symmetricDifferenceSize(Collection<? extends Pair<T,I>> other)` Computes the symmetric difference set size.
`PairSet<T,I>`	`tailSet(Pair<T,I> fromElement)`
`IndexedSet<T>`	`transactionsOf(I item)` Lists all transactions involved with a specified item
`PairSet<I,T>`	`transposed()`
`PairSet<T,I>`	`union(Collection<? extends Pair<T,I>> other)` Generates the union set
`int`	`unionSize(Collection<? extends Pair<T,I>> other)` Computes the union set size.

Methods inherited from class it.uniroma3.mat.extendedset.AbstractExtendedSet
descending, intersectionSize, jaccardDistance, jaccardSimilarity, powerSetSize, powerSetSize, unmodifiable, weightedJaccardDistance, weightedJaccardSimilarity

Methods inherited from class java.util.AbstractCollection
toArray, toArray, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Set
toArray, toArray

- Constructor Detail
 - PairSet
```
public PairSet(BinaryMatrix matrix,
 Collection<T> transactions,
 Collection items)
```
 Initializes the set by specifying all possible transactions and items.
 
 Parameters:
 matrix - BinaryMatrix instance used to internally represent the matrix
 transactions - collection of all possible transactions. The specified order will be preserved within when iterating over the PairSet instance.
 items - collection of all possible items. The specified order will be preserved within each transaction PairSet.
 - PairSet
```
public PairSet(BinaryMatrix matrix,
 Object[][] pairs)
```
 Initializes the set by specifying all possible transactions and items.
 
 Parameters:
 matrix - BinaryMatrix instance used to internally represent the matrix
 pairs - arrays n x 2 of pairs of transactions (first) and items (second).
 - PairSet
```
public PairSet(BinaryMatrix matrix,
 Collection<? extends Pair<T,I>> pairs)
```
 Converts a generic collection of transaction-item pairs to a PairSet instance.
 
 Parameters:
 matrix - IntSet instance used to internally represent the set
 pairs - collection of Pair instances
- Method Detail
 - createFromBinaryMatrix
```
public static PairSet<Integer,Integer> createFromBinaryMatrix(BinaryMatrix b)
```
 Wraps a BinaryMatrix instance with a PairSet instance.
 NOTE: the maximum item and transaction IDs are those existing in the binary matrix when the wrapping take place
 
 Parameters:
 b - a BinaryMatrix instance to wrap
 
 Returns:
 a new PairSet instance, indexed by the given matrix
 - clone
```
public PairSet<T,I> clone()
```
 See the clone() of Object
 NOTE: When overriding this method, please note that Object.clone() is much slower then performing new and "manually" copying data!
 
 Specified by:
 
 clone in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 clone in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 cloned object
 - add
```
public boolean add(Pair<T,I> e)
```
 Specified by:
 
 add in interface Collection<Pair<T,I>>
 
 Specified by:
 
 add in interface Set<Pair<T,I>>
 
 Overrides:
 
 add in class AbstractCollection<Pair<T,I>>
 - add
```
public boolean add(T transaction,
 I item)
```
 Adds a single transaction-item pair
 
 Parameters:
 transaction - the transaction of the pair
 item - the item of the pair
 
 Returns:
 true if the set has been changed
 - addAll
```
public boolean addAll(Collection<? extends Pair<T,I>> c)
```
 Specified by:
 
 addAll in interface Collection<Pair<T,I>>
 
 Specified by:
 
 addAll in interface Set<Pair<T,I>>
 
 Overrides:
 
 addAll in class AbstractCollection<Pair<T,I>>
 - addAll
```
public boolean addAll(Collection<T> trans,
 Collection items)
```
 Add the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - collection of transactions
 items - collection of items
 
 Returns:
 true if the set set has been changed
 - addAll
```
public boolean addAll(T trans,
 Collection items)
```
 Add the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - the given transaction
 items - collection of items
 
 Returns:
 true if the set set has been changed
 - addAll
```
public boolean addAll(Collection<T> trans,
 I item)
```
 Add the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - collection of transactions
 item - the given item
 
 Returns:
 true if the set set has been changed
 - clear
```
public void clear()
```
 Specified by:
 
 clear in interface Collection<Pair<T,I>>
 
 Specified by:
 
 clear in interface Set<Pair<T,I>>
 
 Overrides:
 
 clear in class AbstractCollection<Pair<T,I>>
 - contains
```
public boolean contains(Object o)
```
 Specified by:
 
 contains in interface Collection<Pair<T,I>>
 
 Specified by:
 
 contains in interface Set<Pair<T,I>>
 
 Overrides:
 
 contains in class AbstractCollection<Pair<T,I>>
 - contains
```
public boolean contains(T transaction,
 I item)
```
 Checks if the given transaction-item pair is contained within the set
 
 Parameters:
 transaction - the transaction of the pair
 item - the item of the pair
 
 Returns:
 true if the given transaction-item pair is contained within the set
 - containsAll
```
public boolean containsAll(Collection<?> c)
```
 Specified by:
 
 containsAll in interface Collection<Pair<T,I>>
 
 Specified by:
 
 containsAll in interface Set<Pair<T,I>>
 
 Overrides:
 
 containsAll in class AbstractCollection<Pair<T,I>>
 - containsAll
```
public boolean containsAll(Collection<T> trans,
 Collection items)
```
 Checks if the pairs obtained from the Cartesian product of transactions and items are contained
 
 Parameters:
 trans - collection of transactions
 items - collection of items
 
 Returns:
 true if the pairs set set has been changed
 - containsAll
```
public boolean containsAll(T trans,
 Collection items)
```
 Checks if the pairs obtained from the Cartesian product of transactions and items are contained
 
 Parameters:
 trans - the transaction
 items - collection of items
 
 Returns:
 true if the pairs set set has been changed
 - containsAll
```
public boolean containsAll(Collection<T> trans,
 I item)
```
 Checks if the pairs obtained from the Cartesian product of transactions and items are contained
 
 Parameters:
 trans - collection of transactions
 item - the item
 
 Returns:
 true if the pairs set set has been changed
 - isEmpty
```
public boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface Collection<Pair<T,I>>
 
 Specified by:
 
 isEmpty in interface Set<Pair<T,I>>
 
 Overrides:
 
 isEmpty in class AbstractCollection<Pair<T,I>>
 - iterator
```
public ExtendedSet.ExtendedIterator<Pair<T,I>> iterator()
```
 Specified by:
 
 iterator in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 iterator in interface Iterable<Pair<T,I>>
 
 Specified by:
 
 iterator in interface Collection<Pair<T,I>>
 
 Specified by:
 
 iterator in interface Set<Pair<T,I>>
 
 Specified by:
 
 iterator in class AbstractExtendedSet<Pair<T,I>>
 - descendingIterator
```
public ExtendedSet.ExtendedIterator<Pair<T,I>> descendingIterator()
```
 Gets the descending order iterator over the elements of type T
 
 Specified by:
 
 descendingIterator in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 descendingIterator in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 descending iterator
 - remove
```
public boolean remove(Object o)
```
 Specified by:
 
 remove in interface Collection<Pair<T,I>>
 
 Specified by:
 
 remove in interface Set<Pair<T,I>>
 
 Overrides:
 
 remove in class AbstractCollection<Pair<T,I>>
 - remove
```
public boolean remove(T transaction,
 I item)
```
 Removes a single transaction-item pair
 
 Parameters:
 transaction - the transaction of the pair
 item - the item of the pair
 
 Returns:
 true if the pair set has been changed
 - removeAll
```
public boolean removeAll(Collection<?> c)
```
 Specified by:
 
 removeAll in interface Collection<Pair<T,I>>
 
 Specified by:
 
 removeAll in interface Set<Pair<T,I>>
 
 Overrides:
 
 removeAll in class AbstractSet<Pair<T,I>>
 - retainAll
```
public boolean retainAll(Collection<?> c)
```
 Specified by:
 
 retainAll in interface Collection<Pair<T,I>>
 
 Specified by:
 
 retainAll in interface Set<Pair<T,I>>
 
 Overrides:
 
 retainAll in class AbstractCollection<Pair<T,I>>
 - removeAll
```
public boolean removeAll(Collection<T> trans,
 Collection items)
```
 Removes the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - collection of transactions
 items - collection of items
 
 Returns:
 true if the set set has been changed
 - removeAll
```
public boolean removeAll(T trans,
 Collection items)
```
 Removes the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - a transaction
 items - collection of items
 
 Returns:
 true if the set set has been changed
 - removeAll
```
public boolean removeAll(Collection<T> trans,
 I item)
```
 Removes the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - collection of transactions
 item - collection of items
 
 Returns:
 true if the set set has been changed
 - retainAll
```
public boolean retainAll(Collection<T> trans,
 Collection items)
```
 Retains the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - collection of transactions
 items - collection of items
 
 Returns:
 true if the set set has been changed
 - retainAll
```
public boolean retainAll(T trans,
 Collection items)
```
 Retains the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - the transaction
 items - collection of items
 
 Returns:
 true if the set set has been changed
 - retainAll
```
public boolean retainAll(Collection<T> trans,
 I item)
```
 Retains the pairs obtained from the Cartesian product of transactions and items
 
 Parameters:
 trans - collection of transactions
 item - the item
 
 Returns:
 true if the set set has been changed
 - size
```
public int size()
```
 Specified by:
 
 size in interface Collection<Pair<T,I>>
 
 Specified by:
 
 size in interface Set<Pair<T,I>>
 
 Specified by:
 
 size in class AbstractCollection<Pair<T,I>>
 - allTransactions
```
public IndexedSet<T> allTransactions()
```
 Gets the set of all possible transactions that can be contained within the set
 
 Returns:
 the set of all possible transactions that can be contained within the set
 - allItems
```
public IndexedSet allItems()
```
 Gets the set of all possible items that can be contained within each transaction
 
 Returns:
 the set of all possible items that can be contained within each transaction
 - hashCode
```
public int hashCode()
```
 Specified by:
 
 hashCode in interface Collection<Pair<T,I>>
 
 Specified by:
 
 hashCode in interface Set<Pair<T,I>>
 
 Overrides:
 
 hashCode in class AbstractSet<Pair<T,I>>
 - equals
```
public boolean equals(Object obj)
```
 Specified by:
 
 equals in interface Collection<Pair<T,I>>
 
 Specified by:
 
 equals in interface Set<Pair<T,I>>
 
 Overrides:
 
 equals in class AbstractSet<Pair<T,I>>
 - itemsOf
```
public IndexedSet itemsOf(T transaction)
```
 Lists all items contained within a given transaction
 
 Parameters:
 transaction - the given transaction
 
 Returns:
 items contained within the given transaction
 - transactionsOf
```
public IndexedSet<T> transactionsOf(I item)
```
 Lists all transactions involved with a specified item
 
 Parameters:
 item - the given item
 
 Returns:
 transactions involved with a specified item
 - involvedTransactions
```
public IndexedSet<T> involvedTransactions()
```
 Gets the set of transactions in allTransactions() that contains at least one item
 
 Returns:
 the set of transactions in allTransactions() that contains at least one item
 - involvedItems
```
public IndexedSet involvedItems()
```
 Gets the set of items in allItems() that are contained in at least one transaction
 
 Returns:
 the set of items in allItems() that are contained in at least one transaction
 - get
```
public Pair<T,I> get(int index)
```
 Gets the i^th element of the set
 
 Specified by:
 
 get in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 get in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 index - 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 size()
 - indexOf
```
public int indexOf(Pair<T,I> element)
```
 Provides position of element within the set.
 It returns -1 if the element does not exist within the set.
 
 Specified by:
 
 indexOf in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 indexOf in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 element - element of the set
 
 Returns:
 the element position
 - debugInfo
```
public String debugInfo()
```
 Prints debug info about the given ExtendedSet implementation
 
 Specified by:
 
 debugInfo in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 debugInfo in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 a string that describes the internal representation of the instance
 - bitmapCompressionRatio
```
public 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.)
 
 Specified by:
 
 bitmapCompressionRatio in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 bitmapCompressionRatio in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 the compression factor
 - collectionCompressionRatio
```
public 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.)
 
 Specified by:
 
 collectionCompressionRatio in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 collectionCompressionRatio in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 the compression factor
 - matrix
```
public BinaryMatrix matrix()
```
 Returns the set of indices. Modifications to this set are reflected to this PairSet instance. Trying to perform operation on out-of-bound indices will throw an IllegalArgumentException exception.
 
 Returns:
 the index set
 - empty
```
public PairSet<T,I> empty()
```
 Generates an empty set
 
 Specified by:
 
 empty in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 empty in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 the empty set
 - complement
```
public 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.
 
 Specified by:
 
 complement in interface ExtendedSet<Pair<T,I>>
 
 See Also:
 ExtendedSet.complemented()
 - comparator
```
public Comparator<? super Pair<T,I>> comparator()
```
 Specified by:
 
 comparator in interface SortedSet<Pair<T,I>>
 - convert
```
public PairSet<T,I> 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.
 
 Specified by:
 
 convert in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 convert in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 c - collection to use to generate the new instance
 
 Returns:
 the converted collection
 See Also:
 ExtendedSet.convert(Object...)
 - convert
```
public PairSet<T,I> convert(Object... e)
```
 Converts a given integer array into an instance of the current class
 
 Specified by:
 
 convert in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 convert in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 e - objects to use to generate the new instance
 
 Returns:
 the converted collection
 See Also:
 ExtendedSet.convert(Collection)
 - clear
```
public void clear(Pair<T,I> from,
 Pair<T,I> 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.
 
 Specified by:
 
 clear in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 clear in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 from - first element
 to - last element
 - complementSize
```
public int complementSize()
```
 Computes the complement set size.
 This is faster than calling ExtendedSet.complemented() and then Set.size()
 
 Specified by:
 
 complementSize in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 complementSize in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 the size
 - complemented
```
public PairSet<T,I> 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.
 
 Specified by:
 
 complemented in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 complemented in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 the complement set
 See Also:
 ExtendedSet.complement()
 - difference
```
public PairSet<T,I> difference(Collection<? extends Pair<T,I>> other)
```
 Generates the difference set
 
 Specified by:
 
 difference in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 difference in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - ExtendedSet instance that represents the right operand
 
 Returns:
 the result of the operation
 See Also:
 Set.removeAll(java.util.Collection)
 - containsAny
```
public boolean containsAny(Collection<? extends Pair<T,I>> other)
```
 Returns true if the specified Collection instance contains any elements that are also contained within this ExtendedSet instance
 
 Specified by:
 
 containsAny in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 containsAny in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - ExtendedSet to intersect with
 
 Returns:
 a boolean indicating whether this ExtendedSet intersects the specified ExtendedSet.
 - containsAtLeast
```
public boolean containsAtLeast(Collection<? extends Pair<T,I>> other,
 int minElements)
```
 Returns true if the specified Collection instance contains at least minElements elements that are also contained within this ExtendedSet instance
 
 Specified by:
 
 containsAtLeast in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 containsAtLeast in class AbstractExtendedSet<Pair<T,I>>
 
 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.
 - differenceSize
```
public int differenceSize(Collection<? extends Pair<T,I>> other)
```
 Computes the difference set size.
 This is faster than calling ExtendedSet.difference(Collection) and then Set.size()
 
 Specified by:
 
 differenceSize in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 differenceSize in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - Collection instance that represents the right operand
 
 Returns:
 the size
 - fill
```
public void fill(Pair<T,I> from,
 Pair<T,I> 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.
 
 Specified by:
 
 fill in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 fill in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 from - first element
 to - last element
 - flip
```
public void flip(Pair<T,I> e)
```
 Adds the element if it not existing, or removes it if existing
 
 Specified by:
 
 flip in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 flip in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 e - element to flip
 See Also:
 ExtendedSet.symmetricDifference(Collection)
 - subSet
```
public PairSet<T,I> subSet(Pair<T,I> fromElement,
 Pair<T,I> toElement)
```
 Specified by:
 
 subSet in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 subSet in interface SortedSet<Pair<T,I>>
 
 Overrides:
 
 subSet in class AbstractExtendedSet<Pair<T,I>>
 - headSet
```
public PairSet<T,I> headSet(Pair<T,I> toElement)
```
 Specified by:
 
 headSet in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 headSet in interface SortedSet<Pair<T,I>>
 
 Overrides:
 
 headSet in class AbstractExtendedSet<Pair<T,I>>
 - tailSet
```
public PairSet<T,I> tailSet(Pair<T,I> fromElement)
```
 Specified by:
 
 tailSet in interface ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 tailSet in interface SortedSet<Pair<T,I>>
 
 Overrides:
 
 tailSet in class AbstractExtendedSet<Pair<T,I>>
 - intersection
```
public PairSet<T,I> intersection(Collection<? extends Pair<T,I>> c)
```
 Generates the intersection set
 
 Specified by:
 
 intersection in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 intersection in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 c - ExtendedSet instance that represents the right operand
 
 Returns:
 the result of the operation
 See Also:
 Set.retainAll(java.util.Collection)
 - powerSet
```
public List<? extends PairSet<T,I>> 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.
 
 Specified by:
 
 powerSet in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 powerSet in class AbstractExtendedSet<Pair<T,I>>
 
 Returns:
 the power-set
 See Also:
 ExtendedSet.powerSet(int, int), ExtendedSet.powerSetSize()
 - powerSet
```
public List<? extends PairSet<T,I>> 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.
 
 Specified by:
 
 powerSet in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 powerSet in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 min - minimum subset size (greater than zero)
 max - maximum subset size
 
 Returns:
 the power-set
 See Also:
 ExtendedSet.powerSet(), ExtendedSet.powerSetSize(int, int)
 - symmetricDifference
```
public PairSet<T,I> symmetricDifference(Collection<? extends Pair<T,I>> other)
```
 Generates the symmetric difference set
 
 Specified by:
 
 symmetricDifference in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 symmetricDifference in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - ExtendedSet instance that represents the right operand
 
 Returns:
 the result of the operation
 See Also:
 ExtendedSet.flip(Object)
 - symmetricDifferenceSize
```
public int symmetricDifferenceSize(Collection<? extends Pair<T,I>> other)
```
 Computes the symmetric difference set size.
 This is faster than calling ExtendedSet.symmetricDifference(Collection) and then Set.size()
 
 Specified by:
 
 symmetricDifferenceSize in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 symmetricDifferenceSize in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - Collection instance that represents the right operand
 
 Returns:
 the size
 - union
```
public PairSet<T,I> union(Collection<? extends Pair<T,I>> other)
```
 Generates the union set
 
 Specified by:
 
 union in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 union in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - ExtendedSet instance that represents the right operand
 
 Returns:
 the result of the operation
 See Also:
 Set.addAll(java.util.Collection)
 - unionSize
```
public int unionSize(Collection<? extends Pair<T,I>> other)
```
 Computes the union set size.
 This is faster than calling ExtendedSet.union(Collection) and then Set.size()
 
 Specified by:
 
 unionSize in interface ExtendedSet<Pair<T,I>>
 
 Overrides:
 
 unionSize in class AbstractExtendedSet<Pair<T,I>>
 
 Parameters:
 other - Collection instance that represents the right operand
 
 Returns:
 the size
 - first
```
public Pair<T,I> first()
```
 Specified by:
 
 first in interface SortedSet<Pair<T,I>>
 
 Overrides:
 
 first in class AbstractExtendedSet<Pair<T,I>>
 - last
```
public Pair<T,I> last()
```
 Specified by:
 
 last in interface SortedSet<Pair<T,I>>
 
 Overrides:
 
 last in class AbstractExtendedSet<Pair<T,I>>
 - compareTo
```
public int compareTo(ExtendedSet<Pair<T,I>> 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 ExtendedSet<Pair<T,I>>
 
 Specified by:
 
 compareTo in interface Comparable<ExtendedSet<Pair<T,I>>>
 
 Overrides:
 
 compareTo in class AbstractExtendedSet<Pair<T,I>>
 
 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.
 - transposed
```
public PairSet<I,T> transposed()
```
 Returns:
 a transposed PairSet instance
 - merged
```
public PairSet<T,I> merged(PairSet<T,I> other)
```
 Creates a new PairSet instance with the union of all possible transactions and items as result for allTransactions() and allItems(), respectively, and the union of pairs.
 
 Parameters:
 other - the other PairSet instance to merge
 
 Returns:
 the merged PairSet instance
 - compacted
```
public PairSet<T,I> compacted()
```
 Creates a new PairSet instance with only non-empty transactions and items.
 
 Returns:
 the compacted PairSet instance

Class PairSet<T,I>

Nested Class Summary

Nested classes/interfaces inherited from class it.uniroma3.mat.extendedset.AbstractExtendedSet

Nested classes/interfaces inherited from interface it.uniroma3.mat.extendedset.ExtendedSet

Constructor Summary

Method Summary

Methods inherited from class it.uniroma3.mat.extendedset.AbstractExtendedSet

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Set

Constructor Detail

PairSet

PairSet

PairSet

Method Detail

createFromBinaryMatrix

clone

add

add

addAll

addAll

addAll

addAll

clear

contains

contains

containsAll

containsAll

containsAll

containsAll

isEmpty

iterator

descendingIterator

remove

remove

removeAll

retainAll

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll

size

allTransactions

allItems

hashCode

equals

itemsOf

transactionsOf

involvedTransactions

involvedItems

get

indexOf

debugInfo

bitmapCompressionRatio

collectionCompressionRatio

matrix

empty

complement

comparator

convert

convert

clear

complementSize

complemented

difference

containsAny

containsAtLeast

differenceSize

fill

flip

subSet

headSet

tailSet

intersection

powerSet

powerSet

symmetricDifference

symmetricDifferenceSize