Home >> All

•	us.rconner.* (58)	•	us.rconner.junit.* (1)	•	us.rconner.math.* (24)
•	us.rconner.math.matrix.* (16)	•	us.rconner.util.* (32)	•	us.rconner.util.collection.* (23)

Package Samples:

• us.rconner.math.matrix: Contains algorithms related to combinatorics and number theory, methods to test floating point numbers within tolerance and to compute norms, and some generally useful mathematics-related utilities.  
• us.rconner.util.collection: Contains mutable primitive wrappers.  
• us.rconner.math
• us.rconner.util
• us.rconner.junit
• us.rconner

Classes:

• DefaultMultiMap: A java.util.Map based implementation of the MultiMap interface. This implementation allows the user to choose what implementation class will be used to store the Collection values of this MultiMap . However, any Collection retrieved from this MultiMap (by get( key ) 55 or entrySet 55 ) will not actually be of that implementation. This is because the stored values need to be wrapped so that modifying operations can be intercepted. The returned value will implement one of the following interfaces provided the supplied value class does: java.util.Set java.util.SortedSet java.util.List Bag SortedB ...
• ClassMap: A java.util.HashMap where the keys are java.lang.Class objects. This differs from a standard java.util.Map in that, if a specific class key is not found, it will look for superclasses, super-interfaces, etc. null keys or values are not allowed. This behavior only affects get( key ) 55 , put( key, value ) 55 , and putAll( Map ) 55 . A ClassMap will look for entries in this order: the specified class superclasses implemented interfaces of the specified class implemented interfaces of superclasses default value Note that if this ClassMap has an entry for java.lang.Object , then it will never search ...
• FilteredListIterator: A java.util.ListIterator over a java.util.List filtered by a Predicate . This is much more lightweight, but slower in use, than constructing a FilteredList and iterating over that. This implementation is write-through to the underlying list, but it will not detect changes to the underlying list from outside this implementation. Therefore, this iterator will not be fail-fast; it will instead probably just fail in unpredictable ways. This implementation relies heavily on indexed access to the underlying list, so it will not perform well for sequential lists ( java.util.LinkedList , e.g.).
• IdentityHashSet: An implementation of the java.util.Set interface backed by an java.util.IdentityHashMap . Because this class uses reference equality, it does not obey the general Set contract. This class does not inherit from java.util.AbstractSet because that class's implementation of removeAll( Collection ) 55 does not work with reference equality, and equals( Object ) 55 and hashCode() 55 needed to be overridden anyway.
• FilteredList: A view of a java.util.List filtered by a Predicate . This implementation is rather weighty for a wrapped view, since it effectively constructs the filtered list. Even though this implementation is write-through, it will not detect changes to the underlying list from outside this implementation, and the iterators will not be fail-fast in this case. This implementation relies heavily on indexed access to the underlying list, so it will not perform well for sequential lists ( java.util.LinkedList , e.g.).
• AbstractMatrix: This abstract class provides a mostly complete implementation of the Matrix interface. To implement an unmodifiable Matrix , getRowCount() 55 , getColumnCount() 55 , and get( row, column ) 55 must be implemented. To implement a modifiable Matrix , set( row, column, value ) 55 must be overridden as well.
• Partition: A Partition is a set in which every element is assigned to an equivalence class, here referred to as a "buckets" (for both brevity and unambiguity with regard to java classes). Each bucket is itself a java.util.Set , the set of buckets of a Partition is pairwise disjoint, and the union of all buckets is the same set of elements as the Partition . If an element is added to a bucket and it is already a member of a different bucket in the same partition, it will be moved from the old bucket to the new one, which may result in the old bucket being removed.
• MatrixUtils: This class contains useful static methods for Matrix , Vector , and VectorView objects. It contains shallow Matrix and Vector operations, unmodifiable and synchronized wrappers, and a method to view a Vector as a Matrix .
• MultiMap: A map (similar to, but not a java.util.Map ) which allows multiple values for the same key. Duplicate values for the same key may or may not be allowed by a particular implementation. Objects used as keys should not be mutated in a way that affects either Object.equals( Object ) 55 or Object.hashCode() > Object.hashCode() 55 while the key is in the MultiMap .
• TreeBag: A java.util.TreeMap based implementation of the Bag interface ( this class is not fully implemented ). Object.equals() is used for testing object identity. In other words, adding two distinct objects (not == ) that are .equals() will result in two copies of the first object being present in the TreeBag .
• AbstractVector: This abstract class provides a mostly complete implementation of the Vector interface. To implement an unmodifiable Vector , both getSize() 55 and get( i ) 55 must be implemented. To implement a modifiable Vector , set( i, value ) 55 must be overridden as well.
• TreeMultiMap: A java.util.TreeMap based implementation of the MultiMap interface ( this class is not fully implemented ). Object.equals() is used for testing key identity. In other words, adding two distinct keys (not == ) that are .equals() will result in only the first key being present in the TreeMultiMap .
• FilteredCollection: A view of a java.util.Collection filtered by a Predicate . This implementation is a lazy wrapper and supports all operations except Iterator.remove() > Iterator.remove() 55 .
• CollectionChain: A java.util.Collection which is a view of a list of other Collections chained together. New elements are added to the last Collection and elements are removed from the first Collection in which they are found. This implementation is a lazy wrapper and supports all Collection operations.
• VectorView: A Vector view of a particular row or column of a Matrix .
• SubVector: A Vector which presents a modifiable view of particular elements (specified by index) from another Vector . This class may also be used to present a permuted view of the elements of the wrapped Vector .
• DefaultPartition: A default Partition implementation. This implementation inherits equals() and hashCode() from AbstractSet , and so only checks equality of contained elements, and not bucket structure.
• SubMatrix: A Matrix which presents a modifiable view of particular rows and columns from another Matrix . This class may also be used to present a permuted view of the rows and columns of the wrapped Matrix .
• TransformerUtils: Useful TransformerUtils.IdentityTransformer creational methods and constant values.
• DefaultMapBag: A java.util.Map based implementation of the Bag interface.
• PredicateUtils: Useful PredicateUtils.TruePredicate creational methods and constant values.

Home | Contact Us | Privacy Policy | Terms of Service