You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mahout.apache.org by gs...@apache.org on 2009/12/18 00:22:41 UTC
svn commit: r891983 [26/47] - in /lucene/mahout/trunk: ./ core/
core/src/main/java/org/apache/mahout/cf/taste/hadoop/item/
core/src/main/java/org/apache/mahout/clustering/
core/src/main/java/org/apache/mahout/clustering/canopy/
core/src/main/java/org/a...
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/FloatListAdapter.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/FloatListAdapter.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/FloatListAdapter.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/FloatListAdapter.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,116 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.list.adapter;
+
+import org.apache.mahout.math.list.AbstractFloatList;
+
+import java.util.AbstractList;
+/**
+ * Adapter that permits an {@link org.apache.mahout.math.list.AbstractFloatList} to be viewed and treated as a JDK 1.2 {@link java.util.AbstractList}.
+ * Makes the contained list compatible with the JDK 1.2 Collections Framework.
+ * <p>
+ * Any attempt to pass elements other than <tt>java.lang.Number</tt> to setter methods will throw a <tt>java.lang.ClassCastException</tt>.
+ * <tt>java.lang.Number.floatValue()</tt> is used to convert objects into primitive values which are then stored in the backing templated list.
+ * Getter methods return <tt>java.lang.Float</tt> objects.
+ */
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public class FloatListAdapter extends AbstractList<Float> {
+
+ private final AbstractFloatList content;
+
+ /** Constructs a list backed by the specified content list. */
+ public FloatListAdapter(AbstractFloatList content) {
+ this.content = content;
+ }
+
+ /**
+ * Inserts the specified element at the specified position in this list (optional operation). Shifts the element
+ * currently at that position (if any) and any subsequent elements to the right (adds one to their indices).<p>
+ *
+ * @param index index at which the specified element is to be inserted.
+ * @param element element to be inserted.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException index is out of range (<tt>index < 0 || index > size()</tt>).
+ */
+ @Override
+ public void add(int index, Float element) {
+ content.beforeInsert(index, element);
+ modCount++;
+ }
+
+ /**
+ * Returns the element at the specified position in this list.
+ *
+ * @param index index of element to return.
+ * @return the element at the specified position in this list.
+ * @throws IndexOutOfBoundsException if the given index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Float get(int index) {
+ return content.get(index);
+ }
+
+ /** Transforms an element of a primitive data type to an object. */
+ protected static Object object(float element) {
+ return element;
+ }
+
+ /**
+ * Removes the element at the specified position in this list (optional operation). Shifts any subsequent elements to
+ * the left (subtracts one from their indices). Returns the element that was removed from the list.<p>
+ *
+ * @param index the index of the element to remove.
+ * @return the element previously at the specified position.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Float remove(int index) {
+ Float old = get(index);
+ content.remove(index);
+ modCount++;
+ return old;
+ }
+
+ /**
+ * Replaces the element at the specified position in this list with the specified element (optional operation). <p>
+ *
+ * @param index index of element to replace.
+ * @param element element to be stored at the specified position.
+ * @return the element previously at the specified position.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+
+ @Override
+ public Float set(int index, Float element) {
+ Float old = get(index);
+ content.set(index, element);
+ return old;
+ }
+
+ /**
+ * Returns the number of elements in this list.
+ *
+ * @return the number of elements in this list.
+ */
+ @Override
+ public int size() {
+ return content.size();
+ }
+
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/FloatListAdapter.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/IntListAdapter.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/IntListAdapter.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/IntListAdapter.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/IntListAdapter.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,111 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.list.adapter;
+
+import org.apache.mahout.math.list.AbstractIntList;
+
+import java.util.AbstractList;
+/**
+ * Adapter that permits an {@link org.apache.mahout.math.list.AbstractIntList} to be viewed and treated as a JDK 1.2 {@link java.util.AbstractList}.
+ * Makes the contained list compatible with the JDK 1.2 Collections Framework.
+ * <p>
+ * Any attempt to pass elements other than <tt>java.lang.Number</tt> to setter methods will throw a <tt>java.lang.ClassCastException</tt>.
+ * <tt>java.lang.Number.intValue()</tt> is used to convert objects into primitive values which are then stored in the backing templated list.
+ * Getter methods return <tt>java.lang.Integer</tt> objects.
+ */
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public class IntListAdapter extends AbstractList<Integer> {
+
+ private final AbstractIntList content;
+
+ /** Constructs a list backed by the specified content list. */
+ public IntListAdapter(AbstractIntList content) {
+ this.content = content;
+ }
+
+ /**
+ * Inserts the specified element at the specified position in this list (optional operation). Shifts the element
+ * currently at that position (if any) and any subsequent elements to the right (adds one to their indices).<p>
+ *
+ * @param index index at which the specified element is to be inserted.
+ * @param element element to be inserted.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException index is out of range (<tt>index < 0 || index > size()</tt>).
+ */
+ @Override
+ public void add(int index, Integer element) {
+ content.beforeInsert(index, element);
+ modCount++;
+ }
+
+ /**
+ * Returns the element at the specified position in this list.
+ *
+ * @param index index of element to return.
+ * @return the element at the specified position in this list.
+ * @throws IndexOutOfBoundsException if the given index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Integer get(int index) {
+ return content.get(index);
+ }
+
+ /**
+ * Removes the element at the specified position in this list (optional operation). Shifts any subsequent elements to
+ * the left (subtracts one from their indices). Returns the element that was removed from the list.<p>
+ *
+ * @param index the index of the element to remove.
+ * @return the element previously at the specified position.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Integer remove(int index) {
+ Integer old = get(index);
+ content.remove(index);
+ modCount++;
+ return old;
+ }
+
+ /**
+ * Replaces the element at the specified position in this list with the specified element (optional operation). <p>
+ *
+ * @param index index of element to replace.
+ * @param element element to be stored at the specified position.
+ * @return the element previously at the specified position.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+
+ @Override
+ public Integer set(int index, Integer element) {
+ Integer old = get(index);
+ content.set(index, element);
+ return old;
+ }
+
+ /**
+ * Returns the number of elements in this list.
+ *
+ * @return the number of elements in this list.
+ */
+ @Override
+ public int size() {
+ return content.size();
+ }
+
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/IntListAdapter.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/LongListAdapter.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/LongListAdapter.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/LongListAdapter.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/LongListAdapter.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,111 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.list.adapter;
+
+import org.apache.mahout.math.list.AbstractLongList;
+
+import java.util.AbstractList;
+/**
+ * Adapter that permits an {@link org.apache.mahout.math.list.AbstractLongList} to be viewed and treated as a JDK 1.2 {@link java.util.AbstractList}.
+ * Makes the contained list compatible with the JDK 1.2 Collections Framework.
+ * <p>
+ * Any attempt to pass elements other than <tt>java.lang.Number</tt> to setter methods will throw a <tt>java.lang.ClassCastException</tt>.
+ * <tt>java.lang.Number.longValue()</tt> is used to convert objects into primitive values which are then stored in the backing templated list.
+ * Getter methods return <tt>java.lang.Long</tt> objects.
+ */
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public class LongListAdapter extends AbstractList<Long> {
+
+ private final AbstractLongList content;
+
+ /** Constructs a list backed by the specified content list. */
+ public LongListAdapter(AbstractLongList content) {
+ this.content = content;
+ }
+
+ /**
+ * Inserts the specified element at the specified position in this list (optional operation). Shifts the element
+ * currently at that position (if any) and any subsequent elements to the right (adds one to their indices).<p>
+ *
+ * @param index index at which the specified element is to be inserted.
+ * @param element element to be inserted.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException index is out of range (<tt>index < 0 || index > size()</tt>).
+ */
+ @Override
+ public void add(int index, Long element) {
+ content.beforeInsert(index, element);
+ modCount++;
+ }
+
+ /**
+ * Returns the element at the specified position in this list.
+ *
+ * @param index index of element to return.
+ * @return the element at the specified position in this list.
+ * @throws IndexOutOfBoundsException if the given index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Long get(int index) {
+ return content.get(index);
+ }
+
+ /**
+ * Removes the element at the specified position in this list (optional operation). Shifts any subsequent elements to
+ * the left (subtracts one from their indices). Returns the element that was removed from the list.<p>
+ *
+ * @param index the index of the element to remove.
+ * @return the element previously at the specified position.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Long remove(int index) {
+ Long old = get(index);
+ content.remove(index);
+ modCount++;
+ return old;
+ }
+
+ /**
+ * Replaces the element at the specified position in this list with the specified element (optional operation). <p>
+ *
+ * @param index index of element to replace.
+ * @param element element to be stored at the specified position.
+ * @return the element previously at the specified position.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+
+ @Override
+ public Long set(int index, Long element) {
+ Long old = get(index);
+ content.set(index, element);
+ return old;
+ }
+
+ /**
+ * Returns the number of elements in this list.
+ *
+ * @return the number of elements in this list.
+ */
+ @Override
+ public int size() {
+ return content.size();
+ }
+
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/LongListAdapter.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/ObjectListAdapter.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/ObjectListAdapter.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/ObjectListAdapter.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/ObjectListAdapter.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,106 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.list.adapter;
+
+import org.apache.mahout.math.list.ObjectArrayList;
+
+import java.util.AbstractList;
+/**
+ * Adapter that permits an {@link org.apache.mahout.math.list.ObjectArrayList} to be viewed and treated as a JDK 1.2 {@link java.util.AbstractList}.
+ * Makes the contained list compatible with the JDK 1.2 Collections Framework.
+ */
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public class ObjectListAdapter extends AbstractList<Object> {
+
+ private final ObjectArrayList content;
+
+ /** Constructs a list backed by the specified content list. */
+ public ObjectListAdapter(ObjectArrayList content) {
+ this.content = content;
+ }
+
+ /**
+ * Inserts the specified element at the specified position in this list (optional operation). Shifts the element
+ * currently at that position (if any) and any subsequent elements to the right (adds one to their indices).<p>
+ *
+ * @param index index at which the specified element is to be inserted.
+ * @param element element to be inserted.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException index is out of range (<tt>index < 0 || index > size()</tt>).
+ */
+ @Override
+ public void add(int index, Object element) {
+ content.beforeInsert(index, element);
+ modCount++;
+ }
+
+ /**
+ * Returns the element at the specified position in this list.
+ *
+ * @param index index of element to return.
+ * @return the element at the specified position in this list.
+ * @throws IndexOutOfBoundsException if the given index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Object get(int index) {
+ return content.get(index);
+ }
+
+ /**
+ * Removes the element at the specified position in this list (optional operation). Shifts any subsequent elements to
+ * the left (subtracts one from their indices). Returns the element that was removed from the list.<p>
+ *
+ * @param index the index of the element to remove.
+ * @return the element previously at the specified position.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+ @Override
+ public Object remove(int index) {
+ Object old = get(index);
+ content.remove(index);
+ modCount++;
+ return old;
+ }
+
+ /**
+ * Replaces the element at the specified position in this list with the specified element (optional operation). <p>
+ *
+ * @param index index of element to replace.
+ * @param element element to be stored at the specified position.
+ * @return the element previously at the specified position.
+ * @throws ClassCastException if the class of the specified element prevents it from being added to this list.
+ * @throws IllegalArgumentException if some aspect of the specified element prevents it from being added to this
+ * list.
+ * @throws IndexOutOfBoundsException if the specified index is out of range (<tt>index < 0 || index >=
+ * size()</tt>).
+ */
+
+ @Override
+ public Object set(int index, Object element) {
+ Object old = get(index);
+ content.set(index, element);
+ return old;
+ }
+
+ /**
+ * Returns the number of elements in this list.
+ *
+ * @return the number of elements in this list.
+ */
+ @Override
+ public int size() {
+ return content.size();
+ }
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/ObjectListAdapter.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/package.html
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/package.html?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/package.html (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/package.html Thu Dec 17 23:22:16 2009
@@ -0,0 +1,5 @@
+<HTML>
+<BODY>
+List adapters that make Colt lists compatible with the JDK 1.2 Collections Framework.
+</BODY>
+</HTML>
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/adapter/package.html
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/package.html
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/package.html?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/package.html (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/package.html Thu Dec 17 23:22:16 2009
@@ -0,0 +1,163 @@
+<HTML>
+<BODY>
+Resizable lists holding objects or primitive data types such as <tt>int</tt>,
+<tt>double</tt>, etc. For non-resizable lists (1-dimensional matrices) see
+package {@link org.apache.mahout.math.matrix}.<p></p>
+
+<h1><a name="Overview"></a>Getting Started</h1>
+
+<h2>1. Overview</h2>
+
+<p>The list package offers flexible object oriented abstractions modelling dynamically
+ resizing lists holding objects or primitive data types such as <tt>int</tt>,
+ <tt>double</tt>, etc. It is designed to be scalable in terms of performance
+ and memory requirements.</p>
+
+<p>Features include: </p>
+
+<p></p>
+<ul>
+ <li>Lists operating on objects as well as all primitive data types such as <tt>int</tt>,
+ <tt>double</tt>, etc.
+ </li>
+ <li>Compact representations</li>
+ <li>A number of general purpose list operations including: adding, inserting,
+ removing, iterating, searching, sorting, extracting ranges and copying. All
+ operations are designed to perform well on mass data.
+ </li>
+ <li>Support for quick access to list elements. This is achieved by bounds-checking
+ and non-bounds-checking accessor methods as well as zero-copy transformations
+ to primitive arrays such as <tt>int[]</tt>, <tt>double[]</tt>, etc.
+ </li>
+ <li>Allows to use high level algorithms on primitive data types without any
+ space and time overhead. Operations on primitive arrays, Colt lists and JAL
+ algorithms can freely be mixed at zero copy overhead.
+ </li>
+</ul>
+<p>File-based I/O can be achieved through the standard Java built-in serialization
+ mechanism. All classes implement the {@link java.io.Serializable} interface.
+ However, the toolkit is entirely decoupled from advanced I/O. It provides data
+ structures and algorithms only.
+
+<p> This toolkit borrows concepts and terminology from the Javasoft <a
+ href="http://www.javasoft.com/products/jdk/1.2/docs/guide/collections/index.html">
+ Collections framework</a> written by Josh Bloch and introduced in JDK 1.2.
+
+<h2>2. Introduction</h2>
+
+<p>Lists are fundamental to virtually any application. Large scale resizable lists
+ are, for example, used in scientific computations, simulations database management
+ systems, to name just a few.</p>
+
+<h2></h2>
+
+<p>A list is a container holding elements that can be accessed via zero-based
+ indexes. Lists may be implemented in different ways (most commonly with arrays).
+ A resizable list automatically grows as elements are added. The lists of this
+ package do not automatically shrink. Shrinking needs to be triggered by explicitly
+ calling <tt>trimToSize()</tt> methods.</p>
+
+<p><i>Growing policy</i>: A list implemented with arrays initially has a certain
+ <tt>initialCapacity</tt> - per default 10 elements, but customizable upon instance
+ construction. As elements are added, this capacity may nomore be sufficient.
+ When a list is automatically grown, its capacity is expanded to <tt>1.5*currentCapacity</tt>.
+ Thus, excessive resizing (involving copying) is avoided.</p>
+<h4>Copying</h4>
+
+<p>
+
+<p>Any list can be copied. A copy is <i>equal</i> to the original but entirely
+ independent of the original. So changes in the copy are not reflected in the
+ original, and vice-versa.
+
+<h2>3. Organization of this package</h2>
+
+<p>Class naming follows the schema <tt><ElementType><ImplementationTechnique>List</tt>.
+ For example, we have a {@link org.apache.mahout.math.list.DoubleArrayList}, which is a list
+ holding <tt>double</tt> elements implemented with <tt>double</tt>[] arrays.
+</p>
+
+<p>The classes for lists of a given value type are derived from a common abstract
+ base class tagged <tt>Abstract<ElementType></tt><tt>List</tt>. For example,
+ all lists operating on <tt>double</tt> elements are derived from {@link
+ AbstractDoubleList},
+ which in turn is derived from an abstract base class tying together all lists
+ regardless of value type, {@link org.apache.mahout.math.list.AbstractList}, which finally
+ is rooted in grandmother {@link org.apache.mahout.math.list.AbstractCollection}. The abstract
+ base classes provide skeleton implementations for all but few methods. Experimental
+ data layouts (such as compressed, sparse, linked, etc.) can easily be implemented
+ and inherit a rich set of functionality. Have a look at the javadoc <a href="package-tree.html">tree
+ view</a> to get the broad picture.</p>
+
+<h2>4. Example usage</h2>
+
+<p>The following snippet fills a list, randomizes it, extracts the first half
+ of the elements, sums them up and prints the result. It is implemented entirely
+ with accessor methods.</p>
+<table>
+ <td class="PRE">
+ <pre>
+int s = 1000000;<br>AbstractDoubleList list = new DoubleArrayList();
+for (int i=0; i<s; i++) { list.add((double)i); }
+list.shuffle();
+AbstractDoubleList part = list.partFromTo(0,list.size()/2 - 1);
+double sum = 0.0;
+for (int i=0; i<part.size(); i++) { sum += part.get(i); }
+log.info(sum);
+</pre>
+ </td>
+</table>
+<p> For efficiency, all classes provide back doors to enable getting/setting the
+ backing array directly. In this way, the high level operations of these classes
+ can be used where appropriate, and one can switch to <tt>[]</tt>-array index
+ notations where necessary. The key methods for this are <tt>public <ElementType>[]
+ elements()</tt> and <tt>public void elements(<ElementType>[])</tt>. The
+ former trustingly returns the array it internally keeps to store the elements.
+ Holding this array in hand, we can use the <tt>[]</tt>-array operator to
+ perform iteration over large lists without needing to copy the array or paying
+ the performance penalty introduced by accessor methods. Alternatively any JAL
+ algorithm (or other algorithm) can operate on the returned primitive array.
+ The latter method forces a list to internally hold a user provided array. Using
+ this approach one can avoid needing to copy the elements into the list.
+
+<p>As a consequence, operations on primitive arrays, Colt lists and JAL algorithms
+ can freely be mixed at zero-copy overhead.
+
+<p> Note that such special treatment certainly breaks encapsulation. This functionality
+ is provided for performance reasons only and should only be used when absolutely
+ necessary. Here is the above example in mixed notation:
+<table>
+ <td class="PRE">
+ <pre>
+int s = 1000000;<br>DoubleArrayList list = new DoubleArrayList(s); // list.size()==0, capacity==s
+list.setSize(s); // list.size()==s<br>double[] values = list.elements(); // zero copy, values.length==s<br>for (int i=0; i<s; i++) { values[i]=(double)i; }
+list.shuffle();
+double sum = 0.0;
+int limit = values.length/2;
+for (int i=0; i<limit; i++) { sum += values[i]; }
+log.info(sum);
+</pre>
+ </td>
+</table>
+<p> Or even more compact using lists as algorithm objects:
+<table>
+ <td class="PRE">
+ <pre>
+int s = 1000000;<br>double[] values = new double[s];
+for (int i=0; i<s; i++) { values[i]=(double)i; }
+new DoubleArrayList(values).shuffle(); // zero-copy, shuffle via back door
+double sum = 0.0;
+int limit = values.length/2;
+for (int i=0; i<limit; i++) { sum += values[i]; }
+log.info(sum);
+</pre>
+ </td>
+</table>
+<p>
+
+<h2>5. Notes </h2>
+
+<p>The quicksorts and mergesorts are the JDK 1.2 V1.26 algorithms, modified as
+ necessary to operate on the given data types.
+</BODY>
+</HTML>
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/list/package.html
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractDoubleIntMap.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractDoubleIntMap.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractDoubleIntMap.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractDoubleIntMap.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,443 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.map;
+
+import org.apache.mahout.math.GenericSorting;
+import org.apache.mahout.math.Swapper;
+import org.apache.mahout.math.function.DoubleIntProcedure;
+import org.apache.mahout.math.function.DoubleProcedure;
+import org.apache.mahout.math.function.IntComparator;
+import org.apache.mahout.math.list.DoubleArrayList;
+import org.apache.mahout.math.list.IntArrayList;
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public abstract class AbstractDoubleIntMap extends AbstractMap {
+ //public static int hashCollisions = 0; // for debug only
+
+ /** Makes this class non instantiable, but still let's others inherit from it. */
+ protected AbstractDoubleIntMap() {
+ }
+
+ /**
+ * Returns <tt>true</tt> if the receiver contains the specified key.
+ *
+ * @return <tt>true</tt> if the receiver contains the specified key.
+ */
+ public boolean containsKey(final double key) {
+ return !forEachKey(
+ new DoubleProcedure() {
+ @Override
+ public boolean apply(double iterKey) {
+ return (key != iterKey);
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns <tt>true</tt> if the receiver contains the specified value.
+ *
+ * @return <tt>true</tt> if the receiver contains the specified value.
+ */
+ public boolean containsValue(final int value) {
+ return !forEachPair(
+ new DoubleIntProcedure() {
+ @Override
+ public boolean apply(double iterKey, int iterValue) {
+ return (value != iterValue);
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns a deep copy of the receiver; uses <code>clone()</code> and casts the result.
+ *
+ * @return a deep copy of the receiver.
+ */
+ public AbstractDoubleIntMap copy() {
+ return (AbstractDoubleIntMap) clone();
+ }
+
+ /**
+ * Compares the specified object with this map for equality. Returns <tt>true</tt> if the given object is also a map
+ * and the two maps represent the same mappings. More formally, two maps <tt>m1</tt> and <tt>m2</tt> represent the
+ * same mappings iff
+ * <pre>
+ * m1.forEachPair(
+ * new DoubleIntProcedure() {
+ * public boolean apply(double key, int value) {
+ * return m2.containsKey(key) && m2.get(key) == value;
+ * }
+ * }
+ * )
+ * &&
+ * m2.forEachPair(
+ * new DoubleIntProcedure() {
+ * public boolean apply(double key, int value) {
+ * return m1.containsKey(key) && m1.get(key) == value;
+ * }
+ * }
+ * );
+ * </pre>
+ *
+ * This implementation first checks if the specified object is this map; if so it returns <tt>true</tt>. Then, it
+ * checks if the specified object is a map whose size is identical to the size of this set; if not, it it returns
+ * <tt>false</tt>. If so, it applies the iteration as described above.
+ *
+ * @param obj object to be compared for equality with this map.
+ * @return <tt>true</tt> if the specified object is equal to this map.
+ */
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+
+ if (!(obj instanceof AbstractDoubleIntMap)) {
+ return false;
+ }
+ final AbstractDoubleIntMap other = (AbstractDoubleIntMap) obj;
+ if (other.size() != size()) {
+ return false;
+ }
+
+ return
+ forEachPair(
+ new DoubleIntProcedure() {
+ @Override
+ public boolean apply(double key, int value) {
+ return other.containsKey(key) && other.get(key) == value;
+ }
+ }
+ )
+ &&
+ other.forEachPair(
+ new DoubleIntProcedure() {
+ @Override
+ public boolean apply(double key, int value) {
+ return containsKey(key) && get(key) == value;
+ }
+ }
+ );
+ }
+
+ /**
+ * Applies a procedure to each key of the receiver, if any. Note: Iterates over the keys in no particular order.
+ * Subclasses can define a particular order, for example, "sorted by key". All methods which <i>can</i> be expressed
+ * in terms of this method (most methods can) <i>must guarantee</i> to use the <i>same</i> order defined by this
+ * method, even if it is no particular order. This is necessary so that, for example, methods <tt>keys</tt> and
+ * <tt>values</tt> will yield association pairs, not two uncorrelated lists.
+ *
+ * @param procedure the procedure to be applied. Stops iteration if the procedure returns <tt>false</tt>, otherwise
+ * continues.
+ * @return <tt>false</tt> if the procedure stopped before all keys where iterated over, <tt>true</tt> otherwise.
+ */
+ public abstract boolean forEachKey(DoubleProcedure procedure);
+
+ /**
+ * Applies a procedure to each (key,value) pair of the receiver, if any. Iteration order is guaranteed to be
+ * <i>identical</i> to the order used by method {@link #forEachKey(DoubleProcedure)}.
+ *
+ * @param procedure the procedure to be applied. Stops iteration if the procedure returns <tt>false</tt>, otherwise
+ * continues.
+ * @return <tt>false</tt> if the procedure stopped before all keys where iterated over, <tt>true</tt> otherwise.
+ */
+ public boolean forEachPair(final DoubleIntProcedure procedure) {
+ return forEachKey(
+ new DoubleProcedure() {
+ @Override
+ public boolean apply(double key) {
+ return procedure.apply(key, get(key));
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns the value associated with the specified key. It is often a good idea to first check with {@link
+ * #containsKey(double)} whether the given key has a value associated or not, i.e. whether there exists an association
+ * for the given key or not.
+ *
+ * @param key the key to be searched for.
+ * @return the value associated with the specified key; <tt>0</tt> if no such key is present.
+ */
+ public abstract int get(double key);
+
+ /**
+ * Returns the first key the given value is associated with. It is often a good idea to first check with {@link
+ * #containsValue(int)} whether there exists an association from a key to this value. Search order is guaranteed to be
+ * <i>identical</i> to the order used by method {@link #forEachKey(DoubleProcedure)}.
+ *
+ * @param value the value to search for.
+ * @return the first key for which holds <tt>get(key) == value</tt>; returns <tt>Double.NaN</tt> if no such key
+ * exists.
+ */
+ public double keyOf(final int value) {
+ final double[] foundKey = new double[1];
+ boolean notFound = forEachPair(
+ new DoubleIntProcedure() {
+ @Override
+ public boolean apply(double iterKey, int iterValue) {
+ boolean found = value == iterValue;
+ if (found) {
+ foundKey[0] = iterKey;
+ }
+ return !found;
+ }
+ }
+ );
+ if (notFound) {
+ return Double.NaN;
+ }
+ return foundKey[0];
+ }
+
+ /**
+ * Returns a list filled with all keys contained in the receiver. The returned list has a size that equals
+ * <tt>this.size()</tt>. Note: Keys are filled into the list in no particular order. However, the order is
+ * <i>identical</i> to the order used by method {@link #forEachKey(DoubleProcedure)}. <p> This method can be used to
+ * iterate over the keys of the receiver.
+ *
+ * @return the keys.
+ */
+ public DoubleArrayList keys() {
+ DoubleArrayList list = new DoubleArrayList(size());
+ keys(list);
+ return list;
+ }
+
+ /**
+ * Fills all keys contained in the receiver into the specified list. Fills the list, starting at index 0. After this
+ * call returns the specified list has a new size that equals <tt>this.size()</tt>. Iteration order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(DoubleProcedure)}. <p> This method can be used
+ * to iterate over the keys of the receiver.
+ *
+ * @param list the list to be filled, can have any size.
+ */
+ public void keys(final DoubleArrayList list) {
+ list.clear();
+ forEachKey(
+ new DoubleProcedure() {
+ @Override
+ public boolean apply(double key) {
+ list.add(key);
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Fills all keys <i>sorted ascending by their associated value</i> into the specified list. Fills into the list,
+ * starting at index 0. After this call returns the specified list has a new size that equals <tt>this.size()</tt>.
+ * Primary sort criterium is "value", secondary sort criterium is "key". This means that if any two values are equal,
+ * the smaller key comes first. <p> <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList =
+ * (8,6,7)</tt>
+ *
+ * @param keyList the list to be filled, can have any size.
+ */
+ public void keysSortedByValue(DoubleArrayList keyList) {
+ pairsSortedByValue(keyList, new IntArrayList(size()));
+ }
+
+ /**
+ * Fills all pairs satisfying a given condition into the specified lists. Fills into the lists, starting at index 0.
+ * After this call returns the specified lists both have a new size, the number of pairs satisfying the condition.
+ * Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link
+ * #forEachKey(DoubleProcedure)}. <p> <b>Example:</b> <br>
+ * <pre>
+ * DoubleIntProcedure condition = new DoubleIntProcedure() { // match even values only
+ * public boolean apply(double key, int value) { return value%2==0; }
+ * }
+ * keys = (8,7,6), values = (1,2,2) --> keyList = (6,8), valueList = (2,1)</tt>
+ * </pre>
+ *
+ * @param condition the condition to be matched. Takes the current key as first and the current value as second
+ * argument.
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsMatching(final DoubleIntProcedure condition, final DoubleArrayList keyList,
+ final IntArrayList valueList) {
+ keyList.clear();
+ valueList.clear();
+
+ forEachPair(
+ new DoubleIntProcedure() {
+ @Override
+ public boolean apply(double key, int value) {
+ if (condition.apply(key, value)) {
+ keyList.add(key);
+ valueList.add(value);
+ }
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Fills all keys and values <i>sorted ascending by key</i> into the specified lists. Fills into the lists, starting
+ * at index 0. After this call returns the specified lists both have a new size that equals <tt>this.size()</tt>. <p>
+ * <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList = (6,7,8), valueList = (2,2,1)</tt>
+ *
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsSortedByKey(DoubleArrayList keyList, IntArrayList valueList) {
+ keys(keyList);
+ keyList.sort();
+ valueList.setSize(keyList.size());
+ for (int i = keyList.size(); --i >= 0;) {
+ valueList.setQuick(i, get(keyList.getQuick(i)));
+ }
+ }
+
+ /**
+ * Fills all keys and values <i>sorted ascending by value</i> into the specified lists. Fills into the lists, starting
+ * at index 0. After this call returns the specified lists both have a new size that equals <tt>this.size()</tt>.
+ * Primary sort criterium is "value", secondary sort criterium is "key". This means that if any two values are equal,
+ * the smaller key comes first. <p> <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList = (8,6,7),
+ * valueList = (1,2,2)</tt>
+ *
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsSortedByValue(DoubleArrayList keyList, IntArrayList valueList) {
+ keys(keyList);
+ values(valueList);
+
+ final double[] k = keyList.elements();
+ final int[] v = valueList.elements();
+ Swapper swapper = new Swapper() {
+ @Override
+ public void swap(int a, int b) {
+ int t1 = v[a];
+ v[a] = v[b];
+ v[b] = t1;
+ double t2 = k[a];
+ k[a] = k[b];
+ k[b] = t2;
+ }
+ };
+
+ IntComparator comp = new IntComparator() {
+ @Override
+ public int compare(int a, int b) {
+ return v[a] < v[b] ? -1 : v[a] > v[b] ? 1 : (k[a] < k[b] ? -1 : (k[a] == k[b] ? 0 : 1));
+ }
+ };
+
+ //org.apache.mahout.math.map.OpenDoubleIntHashMap.hashCollisions = 0;
+ GenericSorting.quickSort(0, keyList.size(), comp, swapper);
+ //log.info("collisions="+org.apache.mahout.math.map.OpenDoubleIntHashMap.hashCollisions);
+ }
+
+ /**
+ * Associates the given key with the given value. Replaces any old <tt>(key,someOtherValue)</tt> association, if
+ * existing.
+ *
+ * @param key the key the value shall be associated with.
+ * @param value the value to be associated.
+ * @return <tt>true</tt> if the receiver did not already contain such a key; <tt>false</tt> if the receiver did
+ * already contain such a key - the new value has now replaced the formerly associated value.
+ */
+ public abstract boolean put(double key, int value);
+
+ /**
+ * Removes the given key with its associated element from the receiver, if present.
+ *
+ * @param key the key to be removed from the receiver.
+ * @return <tt>true</tt> if the receiver contained the specified key, <tt>false</tt> otherwise.
+ */
+ public abstract boolean removeKey(double key);
+
+ /**
+ * Returns a string representation of the receiver, containing the String representation of each key-value pair,
+ * sorted ascending by key.
+ */
+ public String toString() {
+ DoubleArrayList theKeys = keys();
+ theKeys.sort();
+
+ StringBuilder buf = new StringBuilder();
+ buf.append('[');
+ int maxIndex = theKeys.size() - 1;
+ for (int i = 0; i <= maxIndex; i++) {
+ double key = theKeys.get(i);
+ buf.append(String.valueOf(key));
+ buf.append("->");
+ buf.append(String.valueOf(get(key)));
+ if (i < maxIndex) {
+ buf.append(", ");
+ }
+ }
+ buf.append(']');
+ return buf.toString();
+ }
+
+ /**
+ * Returns a string representation of the receiver, containing the String representation of each key-value pair,
+ * sorted ascending by value.
+ */
+ public String toStringByValue() {
+ DoubleArrayList theKeys = new DoubleArrayList();
+ keysSortedByValue(theKeys);
+
+ StringBuilder buf = new StringBuilder();
+ buf.append('[');
+ int maxIndex = theKeys.size() - 1;
+ for (int i = 0; i <= maxIndex; i++) {
+ double key = theKeys.get(i);
+ buf.append(String.valueOf(key));
+ buf.append("->");
+ buf.append(String.valueOf(get(key)));
+ if (i < maxIndex) {
+ buf.append(", ");
+ }
+ }
+ buf.append(']');
+ return buf.toString();
+ }
+
+ /**
+ * Returns a list filled with all values contained in the receiver. The returned list has a size that equals
+ * <tt>this.size()</tt>. Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link
+ * #forEachKey(DoubleProcedure)}. <p> This method can be used to iterate over the values of the receiver.
+ *
+ * @return the values.
+ */
+ public IntArrayList values() {
+ IntArrayList list = new IntArrayList(size());
+ values(list);
+ return list;
+ }
+
+ /**
+ * Fills all values contained in the receiver into the specified list. Fills the list, starting at index 0. After this
+ * call returns the specified list has a new size that equals <tt>this.size()</tt>. Iteration order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(DoubleProcedure)}. <p> This method can be used
+ * to iterate over the values of the receiver.
+ *
+ * @param list the list to be filled, can have any size.
+ */
+ public void values(final IntArrayList list) {
+ list.clear();
+ forEachKey(
+ new DoubleProcedure() {
+ @Override
+ public boolean apply(double key) {
+ list.add(get(key));
+ return true;
+ }
+ }
+ );
+ }
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractDoubleIntMap.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntDoubleMap.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntDoubleMap.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntDoubleMap.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntDoubleMap.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,477 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.map;
+
+import org.apache.mahout.math.GenericSorting;
+import org.apache.mahout.math.Swapper;
+import org.apache.mahout.math.function.IntComparator;
+import org.apache.mahout.math.function.IntDoubleProcedure;
+import org.apache.mahout.math.function.IntProcedure;
+import org.apache.mahout.math.list.DoubleArrayList;
+import org.apache.mahout.math.list.IntArrayList;
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public abstract class AbstractIntDoubleMap extends AbstractMap {
+ //public static int hashCollisions = 0; // for debug only
+
+ /** Makes this class non instantiable, but still let's others inherit from it. */
+ protected AbstractIntDoubleMap() {
+ }
+
+ /**
+ * Assigns the result of a function to each value; <tt>v[i] = function(v[i])</tt>.
+ *
+ * @param function a function object taking as argument the current association's value.
+ */
+ public void assign(final org.apache.mahout.math.function.DoubleFunction function) {
+ copy().forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int key, double value) {
+ put(key, function.apply(value));
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Clears the receiver, then adds all (key,value) pairs of <tt>other</tt>values to it.
+ *
+ * @param other the other map to be copied into the receiver.
+ */
+ public void assign(AbstractIntDoubleMap other) {
+ clear();
+ other.forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int key, double value) {
+ put(key, value);
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns <tt>true</tt> if the receiver contains the specified key.
+ *
+ * @return <tt>true</tt> if the receiver contains the specified key.
+ */
+ public boolean containsKey(final int key) {
+ return !forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int iterKey) {
+ return (key != iterKey);
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns <tt>true</tt> if the receiver contains the specified value.
+ *
+ * @return <tt>true</tt> if the receiver contains the specified value.
+ */
+ public boolean containsValue(final double value) {
+ return !forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int iterKey, double iterValue) {
+ return (value != iterValue);
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns a deep copy of the receiver; uses <code>clone()</code> and casts the result.
+ *
+ * @return a deep copy of the receiver.
+ */
+ public AbstractIntDoubleMap copy() {
+ return (AbstractIntDoubleMap) clone();
+ }
+
+ /**
+ * Compares the specified object with this map for equality. Returns <tt>true</tt> if the given object is also a map
+ * and the two maps represent the same mappings. More formally, two maps <tt>m1</tt> and <tt>m2</tt> represent the
+ * same mappings iff
+ * <pre>
+ * m1.forEachPair(
+ * new IntDoubleProcedure() {
+ * public boolean apply(int key, double value) {
+ * return m2.containsKey(key) && m2.get(key) == value;
+ * }
+ * }
+ * )
+ * &&
+ * m2.forEachPair(
+ * new IntDoubleProcedure() {
+ * public boolean apply(int key, double value) {
+ * return m1.containsKey(key) && m1.get(key) == value;
+ * }
+ * }
+ * );
+ * </pre>
+ *
+ * This implementation first checks if the specified object is this map; if so it returns <tt>true</tt>. Then, it
+ * checks if the specified object is a map whose size is identical to the size of this set; if not, it it returns
+ * <tt>false</tt>. If so, it applies the iteration as described above.
+ *
+ * @param obj object to be compared for equality with this map.
+ * @return <tt>true</tt> if the specified object is equal to this map.
+ */
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+
+ if (!(obj instanceof AbstractIntDoubleMap)) {
+ return false;
+ }
+ final AbstractIntDoubleMap other = (AbstractIntDoubleMap) obj;
+ if (other.size() != size()) {
+ return false;
+ }
+
+ return
+ forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int key, double value) {
+ return other.containsKey(key) && other.get(key) == value;
+ }
+ }
+ )
+ &&
+ other.forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int key, double value) {
+ return containsKey(key) && get(key) == value;
+ }
+ }
+ );
+ }
+
+ /**
+ * Applies a procedure to each key of the receiver, if any. Note: Iterates over the keys in no particular order.
+ * Subclasses can define a particular order, for example, "sorted by key". All methods which <i>can</i> be expressed
+ * in terms of this method (most methods can) <i>must guarantee</i> to use the <i>same</i> order defined by this
+ * method, even if it is no particular order. This is necessary so that, for example, methods <tt>keys</tt> and
+ * <tt>values</tt> will yield association pairs, not two uncorrelated lists.
+ *
+ * @param procedure the procedure to be applied. Stops iteration if the procedure returns <tt>false</tt>, otherwise
+ * continues.
+ * @return <tt>false</tt> if the procedure stopped before all keys where iterated over, <tt>true</tt> otherwise.
+ */
+ public abstract boolean forEachKey(IntProcedure procedure);
+
+ /**
+ * Applies a procedure to each (key,value) pair of the receiver, if any. Iteration order is guaranteed to be
+ * <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}.
+ *
+ * @param procedure the procedure to be applied. Stops iteration if the procedure returns <tt>false</tt>, otherwise
+ * continues.
+ * @return <tt>false</tt> if the procedure stopped before all keys where iterated over, <tt>true</tt> otherwise.
+ */
+ public boolean forEachPair(final IntDoubleProcedure procedure) {
+ return forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int key) {
+ return procedure.apply(key, get(key));
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns the value associated with the specified key. It is often a good idea to first check with {@link
+ * #containsKey(int)} whether the given key has a value associated or not, i.e. whether there exists an association
+ * for the given key or not.
+ *
+ * @param key the key to be searched for.
+ * @return the value associated with the specified key; <tt>0</tt> if no such key is present.
+ */
+ public abstract double get(int key);
+
+ /**
+ * Returns the first key the given value is associated with. It is often a good idea to first check with {@link
+ * #containsValue(double)} whether there exists an association from a key to this value. Search order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}.
+ *
+ * @param value the value to search for.
+ * @return the first key for which holds <tt>get(key) == value</tt>; returns <tt>Integer.MIN_VALUE</tt> if no such key
+ * exists.
+ */
+ public int keyOf(final double value) {
+ final int[] foundKey = new int[1];
+ boolean notFound = forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int iterKey, double iterValue) {
+ boolean found = value == iterValue;
+ if (found) {
+ foundKey[0] = iterKey;
+ }
+ return !found;
+ }
+ }
+ );
+ if (notFound) {
+ return Integer.MIN_VALUE;
+ }
+ return foundKey[0];
+ }
+
+ /**
+ * Returns a list filled with all keys contained in the receiver. The returned list has a size that equals
+ * <tt>this.size()</tt>. Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link
+ * #forEachKey(IntProcedure)}. <p> This method can be used to iterate over the keys of the receiver.
+ *
+ * @return the keys.
+ */
+ public IntArrayList keys() {
+ IntArrayList list = new IntArrayList(size());
+ keys(list);
+ return list;
+ }
+
+ /**
+ * Fills all keys contained in the receiver into the specified list. Fills the list, starting at index 0. After this
+ * call returns the specified list has a new size that equals <tt>this.size()</tt>. Iteration order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}. <p> This method can be used to
+ * iterate over the keys of the receiver.
+ *
+ * @param list the list to be filled, can have any size.
+ */
+ public void keys(final IntArrayList list) {
+ list.clear();
+ forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int key) {
+ list.add(key);
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Fills all keys <i>sorted ascending by their associated value</i> into the specified list. Fills into the list,
+ * starting at index 0. After this call returns the specified list has a new size that equals <tt>this.size()</tt>.
+ * Primary sort criterium is "value", secondary sort criterium is "key". This means that if any two values are equal,
+ * the smaller key comes first. <p> <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList =
+ * (8,6,7)</tt>
+ *
+ * @param keyList the list to be filled, can have any size.
+ */
+ public void keysSortedByValue(IntArrayList keyList) {
+ pairsSortedByValue(keyList, new DoubleArrayList(size()));
+ }
+
+ /**
+ * Fills all pairs satisfying a given condition into the specified lists. Fills into the lists, starting at index 0.
+ * After this call returns the specified lists both have a new size, the number of pairs satisfying the condition.
+ * Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}.
+ * <p> <b>Example:</b> <br>
+ * <pre>
+ * IntDoubleProcedure condition = new IntDoubleProcedure() { // match even keys only
+ * public boolean apply(int key, double value) { return key%2==0; }
+ * }
+ * keys = (8,7,6), values = (1,2,2) --> keyList = (6,8), valueList = (2,1)</tt>
+ * </pre>
+ *
+ * @param condition the condition to be matched. Takes the current key as first and the current value as second
+ * argument.
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsMatching(final IntDoubleProcedure condition, final IntArrayList keyList,
+ final DoubleArrayList valueList) {
+ keyList.clear();
+ valueList.clear();
+
+ forEachPair(
+ new IntDoubleProcedure() {
+ @Override
+ public boolean apply(int key, double value) {
+ if (condition.apply(key, value)) {
+ keyList.add(key);
+ valueList.add(value);
+ }
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Fills all keys and values <i>sorted ascending by key</i> into the specified lists. Fills into the lists, starting
+ * at index 0. After this call returns the specified lists both have a new size that equals <tt>this.size()</tt>. <p>
+ * <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList = (6,7,8), valueList = (2,2,1)</tt>
+ *
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsSortedByKey(IntArrayList keyList, DoubleArrayList valueList) {
+ keys(keyList);
+ keyList.sort();
+ valueList.setSize(keyList.size());
+ for (int i = keyList.size(); --i >= 0;) {
+ valueList.setQuick(i, get(keyList.getQuick(i)));
+ }
+ }
+
+ /**
+ * Fills all keys and values <i>sorted ascending by value</i> into the specified lists. Fills into the lists, starting
+ * at index 0. After this call returns the specified lists both have a new size that equals <tt>this.size()</tt>.
+ * Primary sort criterium is "value", secondary sort criterium is "key". This means that if any two values are equal,
+ * the smaller key comes first. <p> <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList = (8,6,7),
+ * valueList = (1,2,2)</tt>
+ *
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsSortedByValue(IntArrayList keyList, DoubleArrayList valueList) {
+ keys(keyList);
+ values(valueList);
+
+ final int[] k = keyList.elements();
+ final double[] v = valueList.elements();
+ Swapper swapper = new Swapper() {
+ @Override
+ public void swap(int a, int b) {
+ double t1 = v[a];
+ v[a] = v[b];
+ v[b] = t1;
+ int t2 = k[a];
+ k[a] = k[b];
+ k[b] = t2;
+ }
+ };
+
+ IntComparator comp = new IntComparator() {
+ @Override
+ public int compare(int a, int b) {
+ return v[a] < v[b] ? -1 : v[a] > v[b] ? 1 : (k[a] < k[b] ? -1 : (k[a] == k[b] ? 0 : 1));
+ }
+ };
+
+ GenericSorting.quickSort(0, keyList.size(), comp, swapper);
+ }
+
+ /**
+ * Associates the given key with the given value. Replaces any old <tt>(key,someOtherValue)</tt> association, if
+ * existing.
+ *
+ * @param key the key the value shall be associated with.
+ * @param value the value to be associated.
+ * @return <tt>true</tt> if the receiver did not already contain such a key; <tt>false</tt> if the receiver did
+ * already contain such a key - the new value has now replaced the formerly associated value.
+ */
+ public abstract boolean put(int key, double value);
+
+ /**
+ * Removes the given key with its associated element from the receiver, if present.
+ *
+ * @param key the key to be removed from the receiver.
+ * @return <tt>true</tt> if the receiver contained the specified key, <tt>false</tt> otherwise.
+ */
+ public abstract boolean removeKey(int key);
+
+ /**
+ * Returns a string representation of the receiver, containing the String representation of each key-value pair,
+ * sorted ascending by key.
+ */
+ public String toString() {
+ IntArrayList theKeys = keys();
+ String tmp = theKeys.toString() + '\n';
+ theKeys.sort();
+
+ StringBuilder buf = new StringBuilder(tmp);
+ //StringBuffer buf = new StringBuffer();
+ buf.append('[');
+ int maxIndex = theKeys.size() - 1;
+ for (int i = 0; i <= maxIndex; i++) {
+ int key = theKeys.get(i);
+ buf.append(String.valueOf(key));
+ buf.append("->");
+ buf.append(String.valueOf(get(key)));
+ if (i < maxIndex) {
+ buf.append(", ");
+ }
+ }
+ buf.append(']');
+ return buf.toString();
+ }
+
+ /**
+ * Returns a string representation of the receiver, containing the String representation of each key-value pair,
+ * sorted ascending by value.
+ */
+ public String toStringByValue() {
+ IntArrayList theKeys = new IntArrayList();
+ keysSortedByValue(theKeys);
+
+ StringBuilder buf = new StringBuilder();
+ buf.append('[');
+ int maxIndex = theKeys.size() - 1;
+ for (int i = 0; i <= maxIndex; i++) {
+ int key = theKeys.get(i);
+ buf.append(String.valueOf(key));
+ buf.append("->");
+ buf.append(String.valueOf(get(key)));
+ if (i < maxIndex) {
+ buf.append(", ");
+ }
+ }
+ buf.append(']');
+ return buf.toString();
+ }
+
+ /**
+ * Returns a list filled with all values contained in the receiver. The returned list has a size that equals
+ * <tt>this.size()</tt>. Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link
+ * #forEachKey(IntProcedure)}. <p> This method can be used to iterate over the values of the receiver.
+ *
+ * @return the values.
+ */
+ public DoubleArrayList values() {
+ DoubleArrayList list = new DoubleArrayList(size());
+ values(list);
+ return list;
+ }
+
+ /**
+ * Fills all values contained in the receiver into the specified list. Fills the list, starting at index 0. After this
+ * call returns the specified list has a new size that equals <tt>this.size()</tt>. Iteration order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}. <p> This method can be used to
+ * iterate over the values of the receiver.
+ *
+ * @param list the list to be filled, can have any size.
+ */
+ public void values(final DoubleArrayList list) {
+ list.clear();
+ forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int key) {
+ list.add(get(key));
+ return true;
+ }
+ }
+ );
+ }
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntDoubleMap.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntIntMap.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntIntMap.java?rev=891983&view=auto
==============================================================================
--- lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntIntMap.java (added)
+++ lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntIntMap.java Thu Dec 17 23:22:16 2009
@@ -0,0 +1,438 @@
+/*
+Copyright � 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+package org.apache.mahout.math.map;
+
+import org.apache.mahout.math.GenericSorting;
+import org.apache.mahout.math.Swapper;
+import org.apache.mahout.math.function.IntComparator;
+import org.apache.mahout.math.function.IntIntProcedure;
+import org.apache.mahout.math.function.IntProcedure;
+import org.apache.mahout.math.list.IntArrayList;
+
+/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
+@Deprecated
+public abstract class AbstractIntIntMap extends AbstractMap {
+ //public static int hashCollisions = 0; // for debug only
+
+ /** Makes this class non instantiable, but still let's others inherit from it. */
+ protected AbstractIntIntMap() {
+ }
+
+ /**
+ * Returns <tt>true</tt> if the receiver contains the specified key.
+ *
+ * @return <tt>true</tt> if the receiver contains the specified key.
+ */
+ public boolean containsKey(final int key) {
+ return !forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int iterKey) {
+ return (key != iterKey);
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns <tt>true</tt> if the receiver contains the specified value.
+ *
+ * @return <tt>true</tt> if the receiver contains the specified value.
+ */
+ public boolean containsValue(final int value) {
+ return !forEachPair(
+ new IntIntProcedure() {
+ @Override
+ public boolean apply(int iterKey, int iterValue) {
+ return (value != iterValue);
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns a deep copy of the receiver; uses <code>clone()</code> and casts the result.
+ *
+ * @return a deep copy of the receiver.
+ */
+ public AbstractIntIntMap copy() {
+ return (AbstractIntIntMap) clone();
+ }
+
+ /**
+ * Compares the specified object with this map for equality. Returns <tt>true</tt> if the given object is also a map
+ * and the two maps represent the same mappings. More formally, two maps <tt>m1</tt> and <tt>m2</tt> represent the
+ * same mappings iff
+ * <pre>
+ * m1.forEachPair(
+ * new IntIntProcedure() {
+ * public boolean apply(int key, int value) {
+ * return m2.containsKey(key) && m2.get(key) == value;
+ * }
+ * }
+ * )
+ * &&
+ * m2.forEachPair(
+ * new IntIntProcedure() {
+ * public boolean apply(int key, int value) {
+ * return m1.containsKey(key) && m1.get(key) == value;
+ * }
+ * }
+ * );
+ * </pre>
+ *
+ * This implementation first checks if the specified object is this map; if so it returns <tt>true</tt>. Then, it
+ * checks if the specified object is a map whose size is identical to the size of this set; if not, it it returns
+ * <tt>false</tt>. If so, it applies the iteration as described above.
+ *
+ * @param obj object to be compared for equality with this map.
+ * @return <tt>true</tt> if the specified object is equal to this map.
+ */
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+
+ if (!(obj instanceof AbstractIntIntMap)) {
+ return false;
+ }
+ final AbstractIntIntMap other = (AbstractIntIntMap) obj;
+ if (other.size() != size()) {
+ return false;
+ }
+
+ return
+ forEachPair(
+ new IntIntProcedure() {
+ @Override
+ public boolean apply(int key, int value) {
+ return other.containsKey(key) && other.get(key) == value;
+ }
+ }
+ )
+ &&
+ other.forEachPair(
+ new IntIntProcedure() {
+ @Override
+ public boolean apply(int key, int value) {
+ return containsKey(key) && get(key) == value;
+ }
+ }
+ );
+ }
+
+ /**
+ * Applies a procedure to each key of the receiver, if any. Note: Iterates over the keys in no particular order.
+ * Subclasses can define a particular order, for example, "sorted by key". All methods which <i>can</i> be expressed
+ * in terms of this method (most methods can) <i>must guarantee</i> to use the <i>same</i> order defined by this
+ * method, even if it is no particular order. This is necessary so that, for example, methods <tt>keys</tt> and
+ * <tt>values</tt> will yield association pairs, not two uncorrelated lists.
+ *
+ * @param procedure the procedure to be applied. Stops iteration if the procedure returns <tt>false</tt>, otherwise
+ * continues.
+ * @return <tt>false</tt> if the procedure stopped before all keys where iterated over, <tt>true</tt> otherwise.
+ */
+ public abstract boolean forEachKey(IntProcedure procedure);
+
+ /**
+ * Applies a procedure to each (key,value) pair of the receiver, if any. Iteration order is guaranteed to be
+ * <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}.
+ *
+ * @param procedure the procedure to be applied. Stops iteration if the procedure returns <tt>false</tt>, otherwise
+ * continues.
+ * @return <tt>false</tt> if the procedure stopped before all keys where iterated over, <tt>true</tt> otherwise.
+ */
+ public boolean forEachPair(final IntIntProcedure procedure) {
+ return forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int key) {
+ return procedure.apply(key, get(key));
+ }
+ }
+ );
+ }
+
+ /**
+ * Returns the value associated with the specified key. It is often a good idea to first check with {@link
+ * #containsKey(int)} whether the given key has a value associated or not, i.e. whether there exists an association
+ * for the given key or not.
+ *
+ * @param key the key to be searched for.
+ * @return the value associated with the specified key; <tt>0</tt> if no such key is present.
+ */
+ public abstract int get(int key);
+
+ /**
+ * Returns the first key the given value is associated with. It is often a good idea to first check with {@link
+ * #containsValue(int)} whether there exists an association from a key to this value. Search order is guaranteed to be
+ * <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}.
+ *
+ * @param value the value to search for.
+ * @return the first key for which holds <tt>get(key) == value</tt>; returns <tt>Integer.MIN_VALUE</tt> if no such key
+ * exists.
+ */
+ public int keyOf(final int value) {
+ final int[] foundKey = new int[1];
+ boolean notFound = forEachPair(
+ new IntIntProcedure() {
+ @Override
+ public boolean apply(int iterKey, int iterValue) {
+ boolean found = value == iterValue;
+ if (found) {
+ foundKey[0] = iterKey;
+ }
+ return !found;
+ }
+ }
+ );
+ if (notFound) {
+ return Integer.MIN_VALUE;
+ }
+ return foundKey[0];
+ }
+
+ /**
+ * Returns a list filled with all keys contained in the receiver. The returned list has a size that equals
+ * <tt>this.size()</tt>. Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link
+ * #forEachKey(IntProcedure)}. <p> This method can be used to iterate over the keys of the receiver.
+ *
+ * @return the keys.
+ */
+ public IntArrayList keys() {
+ IntArrayList list = new IntArrayList(size());
+ keys(list);
+ return list;
+ }
+
+ /**
+ * Fills all keys contained in the receiver into the specified list. Fills the list, starting at index 0. After this
+ * call returns the specified list has a new size that equals <tt>this.size()</tt>. Iteration order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}. <p> This method can be used to
+ * iterate over the keys of the receiver.
+ *
+ * @param list the list to be filled, can have any size.
+ */
+ public void keys(final IntArrayList list) {
+ list.clear();
+ forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int key) {
+ list.add(key);
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Fills all keys <i>sorted ascending by their associated value</i> into the specified list. Fills into the list,
+ * starting at index 0. After this call returns the specified list has a new size that equals <tt>this.size()</tt>.
+ * Primary sort criterium is "value", secondary sort criterium is "key". This means that if any two values are equal,
+ * the smaller key comes first. <p> <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList =
+ * (8,6,7)</tt>
+ *
+ * @param keyList the list to be filled, can have any size.
+ */
+ public void keysSortedByValue(IntArrayList keyList) {
+ pairsSortedByValue(keyList, new IntArrayList(size()));
+ }
+
+ /**
+ * Fills all pairs satisfying a given condition into the specified lists. Fills into the lists, starting at index 0.
+ * After this call returns the specified lists both have a new size, the number of pairs satisfying the condition.
+ * Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}.
+ * <p> <b>Example:</b> <br>
+ * <pre>
+ * IntIntProcedure condition = new IntIntProcedure() { // match even keys only
+ * public boolean apply(int key, int value) { return key%2==0; }
+ * }
+ * keys = (8,7,6), values = (1,2,2) --> keyList = (6,8), valueList = (2,1)</tt>
+ * </pre>
+ *
+ * @param condition the condition to be matched. Takes the current key as first and the current value as second
+ * argument.
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsMatching(final IntIntProcedure condition, final IntArrayList keyList, final IntArrayList valueList) {
+ keyList.clear();
+ valueList.clear();
+
+ forEachPair(
+ new IntIntProcedure() {
+ @Override
+ public boolean apply(int key, int value) {
+ if (condition.apply(key, value)) {
+ keyList.add(key);
+ valueList.add(value);
+ }
+ return true;
+ }
+ }
+ );
+ }
+
+ /**
+ * Fills all keys and values <i>sorted ascending by key</i> into the specified lists. Fills into the lists, starting
+ * at index 0. After this call returns the specified lists both have a new size that equals <tt>this.size()</tt>. <p>
+ * <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList = (6,7,8), valueList = (2,2,1)</tt>
+ *
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsSortedByKey(IntArrayList keyList, IntArrayList valueList) {
+ keys(keyList);
+ keyList.sort();
+ valueList.setSize(keyList.size());
+ for (int i = keyList.size(); --i >= 0;) {
+ valueList.setQuick(i, get(keyList.getQuick(i)));
+ }
+ }
+
+ /**
+ * Fills all keys and values <i>sorted ascending by value</i> into the specified lists. Fills into the lists, starting
+ * at index 0. After this call returns the specified lists both have a new size that equals <tt>this.size()</tt>.
+ * Primary sort criterium is "value", secondary sort criterium is "key". This means that if any two values are equal,
+ * the smaller key comes first. <p> <b>Example:</b> <br> <tt>keys = (8,7,6), values = (1,2,2) --> keyList = (8,6,7),
+ * valueList = (1,2,2)</tt>
+ *
+ * @param keyList the list to be filled with keys, can have any size.
+ * @param valueList the list to be filled with values, can have any size.
+ */
+ public void pairsSortedByValue(IntArrayList keyList, IntArrayList valueList) {
+ keys(keyList);
+ values(valueList);
+
+ final int[] k = keyList.elements();
+ final int[] v = valueList.elements();
+ Swapper swapper = new Swapper() {
+ @Override
+ public void swap(int a, int b) {
+ int t1 = v[a];
+ v[a] = v[b];
+ v[b] = t1;
+ int t2 = k[a];
+ k[a] = k[b];
+ k[b] = t2;
+ }
+ };
+
+ IntComparator comp = new IntComparator() {
+ @Override
+ public int compare(int a, int b) {
+ return v[a] < v[b] ? -1 : v[a] > v[b] ? 1 : (k[a] < k[b] ? -1 : (k[a] == k[b] ? 0 : 1));
+ }
+ };
+
+ GenericSorting.quickSort(0, keyList.size(), comp, swapper);
+ }
+
+ /**
+ * Associates the given key with the given value. Replaces any old <tt>(key,someOtherValue)</tt> association, if
+ * existing.
+ *
+ * @param key the key the value shall be associated with.
+ * @param value the value to be associated.
+ * @return <tt>true</tt> if the receiver did not already contain such a key; <tt>false</tt> if the receiver did
+ * already contain such a key - the new value has now replaced the formerly associated value.
+ */
+ public abstract boolean put(int key, int value);
+
+ /**
+ * Removes the given key with its associated element from the receiver, if present.
+ *
+ * @param key the key to be removed from the receiver.
+ * @return <tt>true</tt> if the receiver contained the specified key, <tt>false</tt> otherwise.
+ */
+ public abstract boolean removeKey(int key);
+
+ /**
+ * Returns a string representation of the receiver, containing the String representation of each key-value pair,
+ * sorted ascending by key.
+ */
+ public String toString() {
+ IntArrayList theKeys = keys();
+ //theKeys.sort();
+
+ StringBuilder buf = new StringBuilder();
+ buf.append('[');
+ int maxIndex = theKeys.size() - 1;
+ for (int i = 0; i <= maxIndex; i++) {
+ int key = theKeys.get(i);
+ buf.append(String.valueOf(key));
+ buf.append("->");
+ buf.append(String.valueOf(get(key)));
+ if (i < maxIndex) {
+ buf.append(", ");
+ }
+ }
+ buf.append(']');
+ return buf.toString();
+ }
+
+ /**
+ * Returns a string representation of the receiver, containing the String representation of each key-value pair,
+ * sorted ascending by value.
+ */
+ public String toStringByValue() {
+ IntArrayList theKeys = new IntArrayList();
+ keysSortedByValue(theKeys);
+
+ StringBuilder buf = new StringBuilder();
+ buf.append('[');
+ int maxIndex = theKeys.size() - 1;
+ for (int i = 0; i <= maxIndex; i++) {
+ int key = theKeys.get(i);
+ buf.append(String.valueOf(key));
+ buf.append("->");
+ buf.append(String.valueOf(get(key)));
+ if (i < maxIndex) {
+ buf.append(", ");
+ }
+ }
+ buf.append(']');
+ return buf.toString();
+ }
+
+ /**
+ * Returns a list filled with all values contained in the receiver. The returned list has a size that equals
+ * <tt>this.size()</tt>. Iteration order is guaranteed to be <i>identical</i> to the order used by method {@link
+ * #forEachKey(IntProcedure)}. <p> This method can be used to iterate over the values of the receiver.
+ *
+ * @return the values.
+ */
+ public IntArrayList values() {
+ IntArrayList list = new IntArrayList(size());
+ values(list);
+ return list;
+ }
+
+ /**
+ * Fills all values contained in the receiver into the specified list. Fills the list, starting at index 0. After this
+ * call returns the specified list has a new size that equals <tt>this.size()</tt>. Iteration order is guaranteed to
+ * be <i>identical</i> to the order used by method {@link #forEachKey(IntProcedure)}. <p> This method can be used to
+ * iterate over the values of the receiver.
+ *
+ * @param list the list to be filled, can have any size.
+ */
+ public void values(final IntArrayList list) {
+ list.clear();
+ forEachKey(
+ new IntProcedure() {
+ @Override
+ public boolean apply(int key) {
+ list.add(get(key));
+ return true;
+ }
+ }
+ );
+ }
+}
Propchange: lucene/mahout/trunk/math/src/main/java/org/apache/mahout/math/map/AbstractIntIntMap.java
------------------------------------------------------------------------------
svn:eol-style = native