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 &lt; 0 || index &gt; 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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt; 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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt; 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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt; 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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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 &lt; 0 || index &gt;=
+   *                                   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>&lt;ElementType&gt;&lt;ImplementationTechnique&gt;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&lt;ElementType&gt;</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&lt;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&lt;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 &lt;ElementType&gt;[]
+    elements()</tt> and <tt>public void elements(&lt;ElementType&gt;[])</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&lt;s; i++) { values[i]=(double)i; }
+list.shuffle();
+double sum = 0.0;
+int limit = values.length/2;
+for (int i=0; i&lt;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&lt;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&lt;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