mahout-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gsing...@apache.org
Subject svn commit: r883365 [33/47] - in /lucene/mahout/trunk: ./ examples/ matrix/ matrix/src/ matrix/src/main/ matrix/src/main/java/ matrix/src/main/java/org/ matrix/src/main/java/org/apache/ matrix/src/main/java/org/apache/mahout/ matrix/src/main/java/org/a...
Date Mon, 23 Nov 2009 15:14:38 GMT
Added: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/DoubleMatrix2DComparator.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/DoubleMatrix2DComparator.java?rev=883365&view=auto
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/DoubleMatrix2DComparator.java (added)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/DoubleMatrix2DComparator.java Mon Nov 23 15:14:26 2009
@@ -0,0 +1,82 @@
+/*
+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.colt.matrix.doublealgo;
+
+import org.apache.mahout.colt.matrix.DoubleMatrix2D;
+/**
+ * A comparison function which imposes a <i>total ordering</i> on some
+ * collection of elements.  Comparators can be passed to a sort method (such as
+ * <tt>org.apache.mahout.colt.matrix.doublealgo.Sorting.quickSort</tt>) to allow precise control over the sort order.<p>
+ *
+ * Note: It is generally a good idea for comparators to implement
+ * <tt>java.io.Serializable</tt>, as they may be used as ordering methods in
+ * serializable data structures.  In
+ * order for the data structure to serialize successfully, the comparator (if
+ * provided) must implement <tt>Serializable</tt>.<p>
+ *
+ * @author wolfgang.hoschek@cern.ch
+ * @version 1.0, 09/24/99
+ * @see java.util.Comparator
+ * @see org.apache.mahout.colt
+ * @see org.apache.mahout.colt.Sorting
+ */
+/** 
+ * @deprecated until unit tests are in place.  Until this time, this class/interface is unsupported.
+ */
+@Deprecated
+public interface DoubleMatrix2DComparator {
+/**
+ * Compares its two arguments for order.  Returns a negative integer,
+ * zero, or a positive integer as the first argument is less than, equal
+ * to, or greater than the second.<p>
+ *
+ * The implementor must ensure that <tt>sgn(compare(x, y)) ==
+ * -sgn(compare(y, x))</tt> for all <tt>x</tt> and <tt>y</tt>.  (This
+ * implies that <tt>compare(x, y)</tt> must throw an exception if and only
+ * if <tt>compare(y, x)</tt> throws an exception.)<p>
+ *
+ * The implementor must also ensure that the relation is transitive:
+ * <tt>((compare(x, y)&gt;0) &amp;&amp; (compare(y, z)&gt;0))</tt> implies
+ * <tt>compare(x, z)&gt;0</tt>.<p>
+ *
+ * Finally, the implementer must ensure that <tt>compare(x, y)==0</tt>
+ * implies that <tt>sgn(compare(x, z))==sgn(compare(y, z))</tt> for all
+ * <tt>z</tt>.<p>
+ *
+ * 
+ * @return a negative integer, zero, or a positive integer as the
+ * 	       first argument is less than, equal to, or greater than the
+ *	       second. 
+ */
+int compare(DoubleMatrix2D o1, DoubleMatrix2D o2);
+/**
+ * 
+ * Indicates whether some other object is &quot;equal to&quot; this
+ * Comparator.  This method must obey the general contract of
+ * <tt>Object.equals(Object)</tt>.  Additionally, this method can return
+ * <tt>true</tt> <i>only</i> if the specified Object is also a comparator
+ * and it imposes the same ordering as this comparator.  Thus,
+ * <code>comp1.equals(comp2)</code> implies that <tt>sgn(comp1.compare(o1,
+ * o2))==sgn(comp2.compare(o1, o2))</tt> for every element
+ * <tt>o1</tt> and <tt>o2</tt>.<p>
+ *
+ * Note that it is <i>always</i> safe <i>not</i> to override
+ * <tt>Object.equals(Object)</tt>.  However, overriding this method may,
+ * in some cases, improve performance by allowing programs to determine
+ * that two distinct Comparators impose the same order.
+ *
+ * @param   obj   the reference object with which to compare.
+ * @return  <code>true</code> only if the specified object is also
+ *		a comparator and it imposes the same ordering as this
+ *		comparator.
+ * @see     java.lang.Object#equals(java.lang.Object)
+ * @see java.lang.Object#hashCode()
+ */
+boolean equals(Object obj);
+}

Propchange: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/DoubleMatrix2DComparator.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Formatter.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Formatter.java?rev=883365&view=auto
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Formatter.java (added)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Formatter.java Mon Nov 23 15:14:26 2009
@@ -0,0 +1,812 @@
+/*
+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.colt.matrix.doublealgo;
+
+import org.apache.mahout.colt.matrix.DoubleMatrix1D;
+import org.apache.mahout.colt.matrix.DoubleMatrix2D;
+import org.apache.mahout.colt.matrix.DoubleMatrix3D;
+import org.apache.mahout.colt.matrix.impl.AbstractFormatter;
+import org.apache.mahout.colt.matrix.impl.AbstractMatrix1D;
+import org.apache.mahout.colt.matrix.impl.AbstractMatrix2D;
+import org.apache.mahout.colt.matrix.impl.DenseDoubleMatrix1D;
+import org.apache.mahout.colt.matrix.impl.Former;
+/** 
+Flexible, well human readable matrix print formatting; By default decimal point aligned. Build on top of the C-like <i>sprintf</i> functionality 
+  provided by the Format class written by Cay Horstmann.
+  Currenly works on 1-d, 2-d and 3-d matrices.
+  Note that in most cases you will not need to get familiar with this class; just call <tt>matrix.toString()</tt> and be happy with the default formatting.
+  This class is for advanced requirements.
+<p> Can't exactly remember the syntax of printf format strings? See Format 
+  or <a href="http://www.braju.com/docs/index.html">Henrik 
+  Nordberg's documentation</a>, or the <a href="http://www.dinkumware.com/htm_cl/lib_prin.html#Print%20Functions">Dinkumware's 
+  C Library Reference</a>.
+  
+<p><b>Examples:</b>
+<p>
+Examples demonstrate usage on 2-d matrices. 1-d and 3-d matrices formatting works very similar.
+<table border="1" cellspacing="0">
+  <tr align="center"> 
+	<td>Original matrix</td>
+  </tr>
+  <tr> 
+	<td> 
+	  
+	  <p><tt>double[][] values = {<br>
+		{3, 0, -3.4, 0},<br>
+		{5.1 ,0, +3.0123456789, 0}, <br>
+		{16.37, 0.0, 2.5, 0}, <br>
+		{-16.3, 0, -3.012345678E-4, -1},<br>
+		{1236.3456789, 0, 7, -1.2}<br>
+		};<br>
+		matrix = new DenseDoubleMatrix2D(values);</tt></p>
+	</td>
+  </tr>
+</table>
+<p>&nbsp;</p>
+<table border="1" cellspacing="0">
+  <tr align="center"> 
+	<td><tt>format</tt></td>
+	<td valign="top"><tt>Formatter.toString(matrix);</tt></td>
+	<td valign="top"><tt>Formatter.toSourceCode(matrix);</tt></td>
+  </tr>
+  <tr> 
+	<td><tt>%G </tt><br>
+	  (default)</td>
+	<td align="left" valign="top"><tt>5&nbsp;x&nbsp;4&nbsp;matrix<br>
+	  &nbsp;&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;-3.4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;<br>
+	  &nbsp;&nbsp;&nbsp;5.1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;3.012346&nbsp;&nbsp;0&nbsp;&nbsp;<br>
+	  &nbsp;&nbsp;16.37&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;<br>
+	  &nbsp;-16.3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;-0.000301&nbsp;-1&nbsp;&nbsp;<br>
+	  1236.345679&nbsp;0&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-1.2 
+	  </tt></td>
+	<td align="left" valign="top"><tt>{<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;-3.4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;&nbsp;0&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;5.1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;&nbsp;3.012346,&nbsp;&nbsp;0&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;16.37&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;&nbsp;0&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;-16.3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;-0.000301,&nbsp;-1&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{1236.345679,&nbsp;0,&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;-1.2}<br>
+	  }; </tt></td>
+  </tr>
+  <tr> 
+	<td><tt>%1.10G</tt></td>
+	<td align="left" valign="top"><tt>5&nbsp;x&nbsp;4&nbsp;matrix<br>
+	  &nbsp;&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;-3.4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;<br>
+	  &nbsp;&nbsp;&nbsp;5.1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;3.0123456789&nbsp;&nbsp;0&nbsp;&nbsp;<br>
+	  &nbsp;&nbsp;16.37&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;<br>
+	  &nbsp;-16.3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0&nbsp;-0.0003012346&nbsp;-1&nbsp;&nbsp;<br>
+	  1236.3456789&nbsp;0&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-1.2 
+	  </tt></td>
+	<td align="left" valign="top"><tt>{<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;-3.4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;&nbsp;0&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;5.1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;&nbsp;3.0123456789,&nbsp;&nbsp;0&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;16.37&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;&nbsp;0&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;-16.3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0,&nbsp;-0.0003012346,&nbsp;-1&nbsp;&nbsp;},<br>
+	  &nbsp;&nbsp;&nbsp;{1236.3456789,&nbsp;0,&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;-1.2}<br>
+	  }; </tt></td>
+  </tr>
+  <tr> 
+	<td><tt>%f</tt></td>
+	<td align="left" valign="top"> <tt> 5&nbsp;x&nbsp;4&nbsp;matrix<br>
+	  &nbsp;&nbsp;&nbsp;3.000000&nbsp;0.000000&nbsp;-3.400000&nbsp;&nbsp;0.000000<br>
+	  &nbsp;&nbsp;&nbsp;5.100000&nbsp;0.000000&nbsp;&nbsp;3.012346&nbsp;&nbsp;0.000000<br>
+	  &nbsp;&nbsp;16.370000&nbsp;0.000000&nbsp;&nbsp;2.500000&nbsp;&nbsp;0.000000<br>
+	  &nbsp;-16.300000&nbsp;0.000000&nbsp;-0.000301&nbsp;-1.000000<br>
+	  1236.345679&nbsp;0.000000&nbsp;&nbsp;7.000000&nbsp;-1.200000 </tt> </td>
+	<td align="left" valign="top"><tt> {<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;3.000000,&nbsp;0.000000,&nbsp;-3.400000,&nbsp;&nbsp;0.000000},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;5.100000,&nbsp;0.000000,&nbsp;&nbsp;3.012346,&nbsp;&nbsp;0.000000},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;16.370000,&nbsp;0.000000,&nbsp;&nbsp;2.500000,&nbsp;&nbsp;0.000000},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;-16.300000,&nbsp;0.000000,&nbsp;-0.000301,&nbsp;-1.000000},<br>
+	  &nbsp;&nbsp;&nbsp;{1236.345679,&nbsp;0.000000,&nbsp;&nbsp;7.000000,&nbsp;-1.200000}<br>
+	  }; </tt> </td>
+  </tr>
+  <tr> 
+	<td><tt>%1.2f</tt></td>
+	<td align="left" valign="top"><tt>5&nbsp;x&nbsp;4&nbsp;matrix<br>
+	  &nbsp;&nbsp;&nbsp;3.00&nbsp;0.00&nbsp;-3.40&nbsp;&nbsp;0.00<br>
+	  &nbsp;&nbsp;&nbsp;5.10&nbsp;0.00&nbsp;&nbsp;3.01&nbsp;&nbsp;0.00<br>
+	  &nbsp;&nbsp;16.37&nbsp;0.00&nbsp;&nbsp;2.50&nbsp;&nbsp;0.00<br>
+	  &nbsp;-16.30&nbsp;0.00&nbsp;-0.00&nbsp;-1.00<br>
+	  1236.35&nbsp;0.00&nbsp;&nbsp;7.00&nbsp;-1.20 </tt></td>
+	<td align="left" valign="top"><tt>{<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;3.00,&nbsp;0.00,&nbsp;-3.40,&nbsp;&nbsp;0.00},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;5.10,&nbsp;0.00,&nbsp;&nbsp;3.01,&nbsp;&nbsp;0.00},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;16.37,&nbsp;0.00,&nbsp;&nbsp;2.50,&nbsp;&nbsp;0.00},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;-16.30,&nbsp;0.00,&nbsp;-0.00,&nbsp;-1.00},<br>
+	  &nbsp;&nbsp;&nbsp;{1236.35,&nbsp;0.00,&nbsp;&nbsp;7.00,&nbsp;-1.20}<br>
+	  }; </tt></td>
+  </tr>
+  <tr> 
+	<td><tt>%0.2e</tt></td>
+	<td align="left" valign="top"><tt>5&nbsp;x&nbsp;4&nbsp;matrix<br>
+	  &nbsp;3.00e+000&nbsp;0.00e+000&nbsp;-3.40e+000&nbsp;&nbsp;0.00e+000<br>
+	  &nbsp;5.10e+000&nbsp;0.00e+000&nbsp;&nbsp;3.01e+000&nbsp;&nbsp;0.00e+000<br>
+	  &nbsp;1.64e+001&nbsp;0.00e+000&nbsp;&nbsp;2.50e+000&nbsp;&nbsp;0.00e+000<br>
+	  -1.63e+001&nbsp;0.00e+000&nbsp;-3.01e-004&nbsp;-1.00e+000<br>
+	  &nbsp;1.24e+003&nbsp;0.00e+000&nbsp;&nbsp;7.00e+000&nbsp;-1.20e+000 </tt></td>
+	<td align="left" valign="top"><tt>{<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;3.00e+000,&nbsp;0.00e+000,&nbsp;-3.40e+000,&nbsp;&nbsp;0.00e+000},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;5.10e+000,&nbsp;0.00e+000,&nbsp;&nbsp;3.01e+000,&nbsp;&nbsp;0.00e+000},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;1.64e+001,&nbsp;0.00e+000,&nbsp;&nbsp;2.50e+000,&nbsp;&nbsp;0.00e+000},<br>
+	  &nbsp;&nbsp;&nbsp;{-1.63e+001,&nbsp;0.00e+000,&nbsp;-3.01e-004,&nbsp;-1.00e+000},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;1.24e+003,&nbsp;0.00e+000,&nbsp;&nbsp;7.00e+000,&nbsp;-1.20e+000}<br>
+	  }; </tt></td>
+  </tr>
+  <tr> 
+	<td><tt>null</tt></td>
+	<td align="left" valign="top"><tt>5&nbsp;x&nbsp;4&nbsp;matrix <br>
+	  &nbsp;&nbsp;&nbsp;3.0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0.0&nbsp;-3.4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0.0<br>
+	  &nbsp;&nbsp;&nbsp;5.1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0.0&nbsp;&nbsp;3.0123456789&nbsp;&nbsp;&nbsp;&nbsp;0.0<br>
+	  &nbsp;&nbsp;16.37&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0.0&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0.0<br>
+	  &nbsp;-16.3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0.0&nbsp;-3.012345678E-4&nbsp;-1.0<br>
+	  1236.3456789&nbsp;0.0&nbsp;&nbsp;7.0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-1.2 
+	  </tt> <tt> </tt></td>
+	<td align="left" valign="top"><tt> {<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;3.0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0.0,&nbsp;-3.4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;&nbsp;0.0},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;&nbsp;5.1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0.0,&nbsp;&nbsp;3.0123456789&nbsp;&nbsp;,&nbsp;&nbsp;0.0},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;&nbsp;16.37&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0.0,&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;&nbsp;0.0},<br>
+	  &nbsp;&nbsp;&nbsp;{&nbsp;-16.3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;0.0,&nbsp;-3.012345678E-4,&nbsp;-1.0},<br>
+	  &nbsp;&nbsp;&nbsp;{1236.3456789,&nbsp;0.0,&nbsp;&nbsp;7.0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;,&nbsp;-1.2}<br>
+	  }; </tt> </td>
+  </tr>
+</table>
+
+<p>Here are some more elaborate examples, adding labels for axes, rows, columns, 
+  title and some statistical aggregations.</p>
+<table border="1" cellspacing="0">
+  <tr> 
+	<td nowrap> 
+	  <p><tt> double[][] values = {<br>
+		{5 ,10, 20, 40 },<br>
+		{ 7, 8 , 6 , 7 },<br>
+		{12 ,10, 20, 19 },<br>
+		{ 3, 1 , 5 , 6 }<br>
+		}; <br>
+		</tt><tt>String title = "CPU performance over time [nops/sec]";<br>
+		String columnAxisName = "Year";<br>
+		String rowAxisName = "CPU"; <br>
+		String[] columnNames = {"1996", "1997", "1998", "1999"};<br>
+		String[] rowNames = { "PowerBar", "Benzol", "Mercedes", "Sparcling"};<br>
+		hep.aida.bin.BinFunctions1D F = hep.aida.bin.BinFunctions1D.functions; // alias<br>
+		hep.aida.bin.BinFunction1D[] aggr = {F.mean, F.rms, F.quantile(0.25), F.median, F.quantile(0.75), F.stdDev, F.min, F.max};<br>
+		String format = "%1.2G";<br>
+		DoubleMatrix2D matrix = new DenseDoubleMatrix2D(values); <br>
+		new Formatter(format).toTitleString(<br>
+		&nbsp;&nbsp;&nbsp;matrix,rowNames,columnNames,rowAxisName,columnAxisName,title,aggr); </tt> 
+	  </p>
+	  </td>
+  </tr>
+  <tr> 
+	<td><tt>
+CPU&nbsp;performance&nbsp;over&nbsp;time&nbsp;[nops/sec]<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;Year<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;1996&nbsp;&nbsp;1997&nbsp;&nbsp;1998&nbsp;&nbsp;1999&nbsp;&nbsp;|&nbsp;Mean&nbsp;&nbsp;RMS&nbsp;&nbsp;&nbsp;25%&nbsp;Q.&nbsp;Median&nbsp;75%&nbsp;Q.&nbsp;StdDev&nbsp;Min&nbsp;Max<br>
+---------------------------------------------------------------------------------------<br>
+C&nbsp;PowerBar&nbsp;&nbsp;|&nbsp;&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;&nbsp;40&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;18.75&nbsp;23.05&nbsp;&nbsp;8.75&nbsp;&nbsp;15&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;25&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;15.48&nbsp;&nbsp;&nbsp;5&nbsp;&nbsp;40&nbsp;<br>
+P&nbsp;Benzol&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;7.04&nbsp;&nbsp;6.75&nbsp;&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;7.25&nbsp;&nbsp;&nbsp;0.82&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;8&nbsp;<br>
+U&nbsp;Mercedes&nbsp;&nbsp;|&nbsp;12&nbsp;&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;&nbsp;19&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;15.25&nbsp;15.85&nbsp;11.5&nbsp;&nbsp;&nbsp;15.5&nbsp;&nbsp;&nbsp;19.25&nbsp;&nbsp;&nbsp;4.99&nbsp;&nbsp;10&nbsp;&nbsp;20&nbsp;<br>
+&nbsp;&nbsp;Sparcling&nbsp;|&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;3.75&nbsp;&nbsp;4.21&nbsp;&nbsp;2.5&nbsp;&nbsp;&nbsp;&nbsp;4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;5.25&nbsp;&nbsp;&nbsp;2.22&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;6&nbsp;<br>
+---------------------------------------------------------------------------------------<br>
+&nbsp;&nbsp;Mean&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;6.75&nbsp;&nbsp;7.25&nbsp;12.75&nbsp;18&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;RMS&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;7.53&nbsp;&nbsp;8.14&nbsp;14.67&nbsp;22.62&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;25%&nbsp;Q.&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;4.5&nbsp;&nbsp;&nbsp;6.25&nbsp;&nbsp;5.75&nbsp;&nbsp;6.75&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;Median&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;9&nbsp;&nbsp;&nbsp;&nbsp;13&nbsp;&nbsp;&nbsp;&nbsp;13&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;75%&nbsp;Q.&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;8.25&nbsp;10&nbsp;&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;&nbsp;24.25&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;StdDev&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;3.86&nbsp;&nbsp;4.27&nbsp;&nbsp;8.38&nbsp;15.81&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;Min&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
+&nbsp;&nbsp;Max&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;12&nbsp;&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;&nbsp;19&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+</tt>
+</td>
+  </tr>
+  <tr> 
+	<td nowrap><tt> same as above, but now without aggregations<br>
+	  aggr=null; </tt> </td>
+  </tr>
+  <tr> 
+	<td><tt> CPU&nbsp;performance&nbsp;over&nbsp;time&nbsp;[nops/sec]<br>
+	  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;Year<br>
+	  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;1996&nbsp;1997&nbsp;1998&nbsp;1999<br>
+	  ---------------------------------<br>
+	  C&nbsp;PowerBar&nbsp;&nbsp;|&nbsp;&nbsp;5&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;40&nbsp;&nbsp;<br>
+	  P&nbsp;Benzol&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;8&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;7&nbsp;&nbsp;<br>
+	  U&nbsp;Mercedes&nbsp;&nbsp;|&nbsp;12&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;19&nbsp;&nbsp;<br>
+	  &nbsp;&nbsp;Sparcling&nbsp;|&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp; 
+	  </tt> </td>
+  </tr>
+  <tr> 
+	<td nowrap>
+	  <p><tt> same as above, but now without rows labeled<br>
+		aggr=null;<br>
+		rowNames=null;<br>
+		rowAxisName=null; </tt> </p>
+	  </td>
+  </tr>
+  <tr> 
+	<td><tt>
+CPU&nbsp;performance&nbsp;over&nbsp;time&nbsp;[nops/sec]<br>
+Year<br>
+1996&nbsp;1997&nbsp;1998&nbsp;1999<br>
+-------------------<br>
+&nbsp;5&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;40&nbsp;&nbsp;<br>
+&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;8&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;7&nbsp;&nbsp;<br>
+12&nbsp;&nbsp;&nbsp;10&nbsp;&nbsp;&nbsp;20&nbsp;&nbsp;&nbsp;19&nbsp;&nbsp;<br>
+&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;6&nbsp;&nbsp;
+</tt>
+</td>
+  </tr>
+</table>
+
+<p>A column can be broader than specified by the parameter <tt>minColumnWidth</tt> 
+  (because a cell may not fit into that width) but a column is never smaller than 
+  <tt>minColumnWidth</tt>. Normally one does not need to specify <tt>minColumnWidth</tt> 
+  (default is <tt>1</tt>). This parameter is only interesting when wanting to 
+  print two distinct matrices such that both matrices have the same column width, 
+  for example, to make it easier to see which column of matrix A corresponds to 
+  which column of matrix B.</p>
+  
+<p><b>Implementation:</b></p>
+
+<p>Note that this class is by no means ment to be used for high performance I/O (serialization is much quicker).
+  It is ment to produce well human readable output.</p>
+<p>Analyzes the entire matrix before producing output. Each cell is converted 
+  to a String as indicated by the given C-like format string. If <tt>null</tt> 
+  is passed as format string, {@link java.lang.Double#toString(double)} is used 
+  instead, yielding full precision.</p>
+<p>Next, leading and trailing whitespaces are removed. For each column the maximum number of characters before 
+  and after the decimal point is determined. (No problem if decimal points are 
+  missing). Each cell is then padded with leading and trailing blanks, as necessary 
+  to achieve decimal point aligned, left justified formatting.</p>
+
+@author wolfgang.hoschek@cern.ch
+@version 1.2, 11/30/99
+*/
+/** 
+ * @deprecated until unit tests are in place.  Until this time, this class/interface is unsupported.
+ */
+@Deprecated
+public class Formatter extends AbstractFormatter {
+/**
+ * Constructs and returns a matrix formatter with format <tt>"%G"</tt>.
+ */
+public Formatter() {
+	this("%G");
+}
+/**
+ * Constructs and returns a matrix formatter.
+ * @param format the given format used to convert a single cell value.
+ */
+public Formatter(String format) {
+	setFormat(format);
+	setAlignment(DECIMAL);
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo1() {
+// parameters
+double[][] values = {
+	{3,     0,        -3.4, 0},
+	{5.1   ,0,        +3.0123456789, 0},
+	{16.37, 0.0,       2.5, 0},
+	{-16.3, 0,        -3.012345678E-4, -1},
+	{1236.3456789, 0,  7, -1.2}
+};
+String[] formats =         {"%G", "%1.10G", "%f", "%1.2f", "%0.2e", null};
+
+
+// now the processing
+int size = formats.length;
+DoubleMatrix2D matrix = org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values);
+String[] strings = new String[size];
+String[] sourceCodes = new String[size];
+String[] htmlStrings = new String[size];
+String[] htmlSourceCodes = new String[size];
+
+for (int i=0; i<size; i++) {
+	String format = formats[i];
+	strings[i] = new Formatter(format).toString(matrix);
+	sourceCodes[i] = new Formatter(format).toSourceCode(matrix);
+
+	// may not compile because of packages not included in the distribution
+	//htmlStrings[i] = org.apache.mahout.colt.matrixpattern.Converting.toHTML(strings[i]);
+	//htmlSourceCodes[i] = org.apache.mahout.colt.matrixpattern.Converting.toHTML(sourceCodes[i]);
+}
+
+System.out.println("original:\n"+new Formatter().toString(matrix));
+
+// may not compile because of packages not included in the distribution
+for (int i=0; i<size; i++) {
+	//System.out.println("\nhtmlString("+formats[i]+"):\n"+htmlStrings[i]);
+	//System.out.println("\nhtmlSourceCode("+formats[i]+"):\n"+htmlSourceCodes[i]);
+}
+
+for (int i=0; i<size; i++) {
+	System.out.println("\nstring("+formats[i]+"):\n"+strings[i]);
+	System.out.println("\nsourceCode("+formats[i]+"):\n"+sourceCodes[i]);
+}
+
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo2() {
+// parameters
+double[] values = {
+	//5, 0.0, -0.0, -Double.NaN, Double.NaN, 0.0/0.0, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.MIN_VALUE, Double.MAX_VALUE
+	5, 0.0, -0.0, -Double.NaN, Double.NaN, 0.0/0.0, Double.MIN_VALUE, Double.MAX_VALUE , Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY
+	//Double.MIN_VALUE, Double.MAX_VALUE //, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY
+};
+//String[] formats =         {"%G", "%1.10G", "%f", "%1.2f", "%0.2e"};
+String[] formats =         {"%G", "%1.19G"};
+
+
+// now the processing
+int size = formats.length;
+DoubleMatrix1D matrix = new DenseDoubleMatrix1D(values);
+
+String[] strings = new String[size];
+//String[] javaStrings = new String[size];
+
+for (int i=0; i<size; i++) {
+	String format = formats[i];
+	strings[i] = new Formatter(format).toString(matrix);
+	for (int j=0; j<matrix.size(); j++) {
+		System.out.println(String.valueOf(matrix.get(j)));
+	}
+}
+
+System.out.println("original:\n"+new Formatter().toString(matrix));
+
+for (int i=0; i<size; i++) {
+	System.out.println("\nstring("+formats[i]+"):\n"+strings[i]);
+}
+
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo3(int size, double value) {
+	org.apache.mahout.colt.Timer timer = new org.apache.mahout.colt.Timer();
+	String s;
+	StringBuffer buf;
+	DoubleMatrix2D matrix = org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(size,size, value);
+
+	timer.reset().start();
+	buf = new StringBuffer();
+	for (int i=size; --i >= 0; ) {
+		for (int j=size; --j >= 0; ) {
+			buf.append(matrix.getQuick(i,j));
+		}
+	}
+	buf = null;
+	timer.stop().display();
+
+	timer.reset().start();
+	org.apache.mahout.colt.matrix.impl.Former format = new org.apache.mahout.colt.matrix.impl.FormerFactory().create("%G");
+	buf = new StringBuffer();
+	for (int i=size; --i >= 0; ) {
+		for (int j=size; --j >= 0; ) {
+			buf.append(format.form(matrix.getQuick(i,j)));
+		}
+	}
+	buf = null;
+	timer.stop().display();
+
+	timer.reset().start();
+	s = new Formatter(null).toString(matrix);
+	//System.out.println(s);
+	s = null;
+	timer.stop().display();
+
+	timer.reset().start();
+	s = new Formatter("%G").toString(matrix);
+	//System.out.println(s);
+	s = null;
+	timer.stop().display();
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo4() {
+// parameters
+double[][] values = {
+	{3,     0,        -3.4, 0},
+	{5.1   ,0,        +3.0123456789, 0},
+	{16.37, 0.0,       2.5, 0},
+	{-16.3, 0,        -3.012345678E-4, -1},
+	{1236.3456789, 0,  7, -1.2}
+};
+/*
+double[][] values = {
+	{3,     1,      },
+	{5.1   ,16.37,  }
+};
+*/
+//String[] columnNames = { "he",   "",  "he", "four" };
+//String[] rowNames = { "hello", "du", null, "abcdef", "five" };
+String[] columnNames = { "0.1", "0.3", "0.5", "0.7" };
+String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2" };
+//String[] columnNames = { "0.1", "0.3" };
+//String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8"};
+
+DoubleMatrix2D matrix = org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values);
+System.out.println("\n\n"+new Formatter("%G").toTitleString(matrix,rowNames,columnNames,"rowAxis","colAxis","VM Performance: Provider vs. matrix density"));
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo5() {
+// parameters
+double[][] values = {
+	{3,     0,        -3.4, 0},
+	{5.1   ,0,        +3.0123456789, 0},
+	{16.37, 0.0,       2.5, 0},
+	{-16.3, 0,        -3.012345678E-4, -1},
+	{1236.3456789, 0,  7, -1.2}
+};
+/*
+double[][] values = {
+	{3,     1,      },
+	{5.1   ,16.37,  }
+};
+*/
+//String[] columnNames = { "he",   "",  "he", "four" };
+//String[] rowNames = { "hello", "du", null, "abcdef", "five" };
+String[] columnNames = { "0.1", "0.3", "0.5", "0.7" };
+String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2" };
+//String[] columnNames = { "0.1", "0.3" };
+//String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8"};
+
+System.out.println(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values));
+System.out.println(new Formatter("%G").toTitleString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values),rowNames,columnNames,"vendor","density","title"));
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo6() {
+// parameters
+double[][] values = {
+	{3,     0,        -3.4, 0},
+	{5.1   ,0,        +3.0123456789, 0},
+	{16.37, 0.0,       2.5, 0},
+	{-16.3, 0,        -3.012345678E-4, -1},
+	{1236.3456789, 0,  7, -1.2}
+};
+/*
+double[][] values = {
+	{3,     1,      },
+	{5.1   ,16.37,  }
+};
+*/
+//String[] columnNames = { "he",   "",  "he", "four" };
+//String[] rowNames = { "hello", "du", null, "abcdef", "five" };
+//String[] columnNames = { "0.1", "0.3", "0.5", "0.7" };
+String[] columnNames = { "W", "X", "Y", "Z"};
+String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2" };
+//String[] columnNames = { "0.1", "0.3" };
+//String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8"};
+
+//System.out.println(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values));
+//System.out.println(new Formatter().toSourceCode(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values)));
+System.out.println(new Formatter().toString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values)));
+System.out.println(new Formatter().toTitleString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values),rowNames,columnNames,"vendor","density","title"));
+}
+/**
+ * Demonstrates how to use this class.
+ */
+public static void demo7() {
+// parameters
+/*
+double[][] values = {
+	{3,     0,        -3.4, 0},
+	{5.1   ,0,        +3.0123456789, 0},
+	{16.37, 0.0,       2.5, 0},
+	{-16.3, 0,        -3.012345678E-4, -1},
+	{1236.3456789, 0,  7, -1.2}
+};
+*/
+double[][] values = {
+	{5  ,10, 20, 40 },
+	{ 7,  8 , 6 , 7 },
+	{12 ,10, 20, 19 },
+	{ 3,  1 , 5 , 6 }
+};
+String[] columnNames = {"1996", "1997", "1998", "1999"};
+String[] rowNames = { "PowerBar", "Benzol", "Mercedes", "Sparcling"};
+String rowAxisName = "CPU";
+String columnAxisName = "Year";
+String title = "CPU performance over time [nops/sec]";
+//hep.aida.bin.BinFunctions1D F = hep.aida.bin.BinFunctions1D.functions;
+//hep.aida.bin.BinFunction1D[] aggr = {F.mean, F.rms, F.quantile(0.25), F.median,F.quantile(0.75), F.stdDev, F.min, F.max};
+String format = "%1.2G";
+
+//String[] columnNames = { "W", "X", "Y", "Z", "mean", "median", "sum"};
+//String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2", "mean", "median", "sum" };
+//hep.aida.bin.BinFunction1D[] aggr = {F.mean, F.median, F.sum};
+
+//System.out.println(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values));
+//System.out.println(new Formatter().toSourceCode(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values)));
+//System.out.println(new Formatter().toString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values)));
+//System.out.println(new Formatter().toTitleString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values),rowNames,columnNames,rowAxisName,columnAxisName,title));
+//System.out.println(new Formatter(format).toTitleString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values),rowNames,columnNames,rowAxisName,columnAxisName,title, aggr));
+//System.out.println(org.apache.mahout.colt.matrixpattern.Converting.toHTML(new Formatter(format).toTitleString(org.apache.mahout.colt.matrix.DoubleFactory2D.dense.make(values),rowNames,columnNames,rowAxisName,columnAxisName,title, aggr)));
+}
+/**
+ * Converts a given cell to a String; no alignment considered.
+ */
+protected String form(DoubleMatrix1D matrix, int index, Former formatter) {
+	return formatter.form(matrix.get(index));
+}
+/**
+ * Converts a given cell to a String; no alignment considered.
+ */
+protected String form(AbstractMatrix1D matrix, int index, Former formatter) {
+	return this.form((DoubleMatrix1D) matrix, index, formatter);
+}
+/**
+ * Returns a string representations of all cells; no alignment considered.
+ */
+public String[][] format(DoubleMatrix2D matrix) {
+	String[][] strings = new String[matrix.rows()][matrix.columns()];
+	for (int row=matrix.rows(); --row >= 0; ) strings[row] = formatRow(matrix.viewRow(row));
+	return strings;
+}
+/**
+ * Returns a string representations of all cells; no alignment considered.
+ */
+protected String[][] format(AbstractMatrix2D matrix) {
+	return this.format((DoubleMatrix2D) matrix);
+}
+/**
+ * Returns the index of the decimal point.
+ */
+protected int indexOfDecimalPoint(String s) {
+	int i = s.lastIndexOf('.');
+	if (i<0) i = s.lastIndexOf('e');
+	if (i<0) i = s.lastIndexOf('E');
+	if (i<0) i = s.length();
+	return i;
+}
+/**
+ * Returns the number of characters before the decimal point.
+ */
+protected int lead(String s) {
+	if (alignment.equals(DECIMAL)) return indexOfDecimalPoint(s);
+	return super.lead(s);
+}
+/**
+ * Returns a string <tt>s</tt> such that <tt>Object[] m = s</tt> is a legal Java statement.
+ * @param matrix the matrix to format.
+ */
+public String toSourceCode(DoubleMatrix1D matrix) {
+	Formatter copy = (Formatter) this.clone();
+	copy.setPrintShape(false);
+	copy.setColumnSeparator(", ");
+	String lead  = "{";
+	String trail = "};";
+	return lead + copy.toString(matrix) + trail;
+}
+/**
+ * Returns a string <tt>s</tt> such that <tt>Object[] m = s</tt> is a legal Java statement.
+ * @param matrix the matrix to format.
+ */
+public String toSourceCode(DoubleMatrix2D matrix) {
+	Formatter copy = (Formatter) this.clone();
+	String b3 = blanks(3);
+	copy.setPrintShape(false);
+	copy.setColumnSeparator(", ");
+	copy.setRowSeparator("},\n"+b3+"{");
+	String lead  = "{\n"+b3+"{";
+	String trail = "}\n};";
+	return lead + copy.toString(matrix) + trail;
+}
+/**
+ * Returns a string <tt>s</tt> such that <tt>Object[] m = s</tt> is a legal Java statement.
+ * @param matrix the matrix to format.
+ */
+public String toSourceCode(DoubleMatrix3D matrix) {
+	Formatter copy = (Formatter) this.clone();
+	String b3 = blanks(3);
+	String b6 = blanks(6);
+	copy.setPrintShape(false);
+	copy.setColumnSeparator(", ");
+	copy.setRowSeparator("},\n"+b6+"{");
+	copy.setSliceSeparator("}\n"+b3+"},\n"+b3+"{\n"+b6+"{");
+	String lead  = "{\n"+b3+"{\n"+b6+"{";
+	String trail = "}\n"+b3+"}\n}";
+	return lead + copy.toString(matrix) + trail;
+}
+/**
+ * Returns a string representation of the given matrix.
+ * @param matrix the matrix to convert.
+ */
+public String toString(DoubleMatrix1D matrix) {
+	DoubleMatrix2D easy = matrix.like2D(1,matrix.size());
+	easy.viewRow(0).assign(matrix);
+	return toString(easy);
+}
+/**
+ * Returns a string representation of the given matrix.
+ * @param matrix the matrix to convert.
+ */
+public String toString(DoubleMatrix2D matrix) {
+	return super.toString(matrix);
+}
+/**
+ * Returns a string representation of the given matrix.
+ * @param matrix the matrix to convert.
+ */
+public String toString(DoubleMatrix3D matrix) {
+	StringBuffer buf = new StringBuffer();
+	boolean oldPrintShape = this.printShape;
+	this.printShape = false;
+	for (int slice=0; slice < matrix.slices(); slice++) {
+		if (slice!=0) buf.append(sliceSeparator);
+		buf.append(toString(matrix.viewSlice(slice)));
+	}
+	this.printShape = oldPrintShape;	
+	if (printShape) buf.insert(0,shape(matrix) + "\n");
+	return buf.toString();
+}
+/**
+ * Returns a string representation of the given matrix.
+ * @param matrix the matrix to convert.
+ */
+protected String toString(AbstractMatrix2D matrix) {
+	return this.toString((DoubleMatrix2D) matrix);
+}
+/**
+Returns a string representation of the given matrix with axis as well as rows and columns labeled.
+Pass <tt>null</tt> to one or more parameters to indicate that the corresponding decoration element shall not appear in the string converted matrix.
+
+@param matrix The matrix to format.
+@param rowNames The headers of all rows (to be put to the left of the matrix).
+@param columnNames The headers of all columns (to be put to above the matrix).
+@param rowAxisName The label of the y-axis.
+@param columnAxisName The label of the x-axis.
+@param title The overall title of the matrix to be formatted.
+@return the matrix converted to a string.
+*/
+protected String toTitleString(DoubleMatrix2D matrix, String[] rowNames, String[] columnNames, String rowAxisName, String columnAxisName, String title) {
+	if (matrix.size()==0) return "Empty matrix";
+	String[][] s = format(matrix);
+	//String oldAlignment = this.alignment;
+	//this.alignment = DECIMAL;
+	align(s);
+	//this.alignment = oldAlignment;
+	return new org.apache.mahout.colt.matrix.objectalgo.Formatter().toTitleString(org.apache.mahout.colt.matrix.ObjectFactory2D.dense.make(s), rowNames,columnNames,rowAxisName,columnAxisName,title);
+}
+/**
+Same as <tt>toTitleString</tt> except that additionally statistical aggregates (mean, median, sum, etc.) of rows and columns are printed.
+Pass <tt>null</tt> to one or more parameters to indicate that the corresponding decoration element shall not appear in the string converted matrix.
+
+@param matrix The matrix to format.
+@param rowNames The headers of all rows (to be put to the left of the matrix).
+@param columnNames The headers of all columns (to be put to above the matrix).
+@param rowAxisName The label of the y-axis.
+@param columnAxisName The label of the x-axis.
+@param title The overall title of the matrix to be formatted.
+@param aggr the aggregation functions to be applied to columns and rows.
+@return the matrix converted to a string.
+@see hep.aida.bin.BinFunction1D
+@see hep.aida.bin.BinFunctions1D
+
+public String toTitleString(DoubleMatrix2D matrix, String[] rowNames, String[] columnNames, String rowAxisName, String columnAxisName, String title, hep.aida.bin.BinFunction1D[] aggr) {
+	if (matrix.size()==0) return "Empty matrix";
+	if (aggr==null || aggr.length==0) return toTitleString(matrix,rowNames,columnNames,rowAxisName,columnAxisName,title);
+	
+	DoubleMatrix2D rowStats = matrix.like(matrix.rows(), aggr.length); // hold row aggregations
+	DoubleMatrix2D colStats = matrix.like(aggr.length, matrix.columns()); // hold column aggregations
+
+	org.apache.mahout.colt.matrix.doublealgo.Statistic.aggregate(matrix, aggr, colStats); // aggregate an entire column at a time
+	org.apache.mahout.colt.matrix.doublealgo.Statistic.aggregate(matrix.viewDice(), aggr, rowStats.viewDice()); // aggregate an entire row at a time
+
+	// turn into strings
+	// tmp holds "matrix" plus "colStats" below (needed so that numbers in a columns can be decimal point aligned)
+	DoubleMatrix2D tmp = matrix.like(matrix.rows()+aggr.length, matrix.columns());
+	tmp.viewPart(0,0,matrix.rows(),matrix.columns()).assign(matrix);
+	tmp.viewPart(matrix.rows(),0,aggr.length,matrix.columns()).assign(colStats);
+	colStats = null;
+
+	String[][] s1 = format(tmp); align(s1); tmp = null;
+	String[][] s2 = format(rowStats); align(s2); rowStats = null;
+
+	// copy strings into a large matrix holding the source matrix and all aggregations
+	org.apache.mahout.colt.matrix.ObjectMatrix2D allStats = org.apache.mahout.colt.matrix.ObjectFactory2D.dense.make(matrix.rows()+aggr.length, matrix.columns()+aggr.length+1);
+	allStats.viewPart(0,0,matrix.rows()+aggr.length,matrix.columns()).assign(s1);
+	allStats.viewColumn(matrix.columns()).assign("|");
+	allStats.viewPart(0,matrix.columns()+1,matrix.rows(),aggr.length).assign(s2);
+	s1 = null; s2 = null;
+
+	// append a vertical "|" separator plus names of aggregation functions to line holding columnNames
+	if (columnNames!=null) {
+		org.apache.mahout.colt.list.ObjectArrayList list = new org.apache.mahout.colt.list.ObjectArrayList(columnNames);
+		list.add("|");
+		for (int i=0; i<aggr.length; i++) list.add(aggr[i].name()); // add names of aggregation functions
+		columnNames = new String[list.size()];
+		list.toArray(columnNames);
+	}
+
+	// append names of aggregation functions to line holding rowNames
+	if (rowNames!=null) {
+		org.apache.mahout.colt.list.ObjectArrayList list = new org.apache.mahout.colt.list.ObjectArrayList(rowNames);
+		for (int i=0; i<aggr.length; i++) list.add(aggr[i].name()); // add names of aggregation functions
+		rowNames = new String[list.size()];
+		list.toArray(rowNames);
+	}	
+	
+	// turn large matrix into string
+	String s = new org.apache.mahout.colt.matrix.objectalgo.Formatter().toTitleString(allStats, rowNames,columnNames,rowAxisName,columnAxisName,title);
+	
+	// insert a horizontal "----------------------" separation line above the column stats
+	// determine insertion position and line width
+	int last = s.length()+1;
+	int secondLast = last;
+	int v = Math.max(0, rowAxisName==null ? 0 : rowAxisName.length()-matrix.rows()-aggr.length);
+	for (int k=0; k<aggr.length+1+v; k++) { // scan "aggr.length+1+v" lines backwards
+		secondLast = last;
+		last = s.lastIndexOf(rowSeparator, last-1);
+	}
+	StringBuffer buf = new StringBuffer(s);
+	buf.insert(secondLast,rowSeparator+repeat('-',secondLast-last-1));
+	
+	return buf.toString();
+}
+*/
+/**
+Returns a string representation of the given matrix with axis as well as rows and columns labeled.
+Pass <tt>null</tt> to one or more parameters to indicate that the corresponding decoration element shall not appear in the string converted matrix.
+
+@param matrix The matrix to format.
+@param sliceNames The headers of all slices (to be put above each slice).
+@param rowNames The headers of all rows (to be put to the left of the matrix).
+@param columnNames The headers of all columns (to be put to above the matrix).
+@param sliceAxisName The label of the z-axis (to be put above each slice).
+@param rowAxisName The label of the y-axis.
+@param columnAxisName The label of the x-axis.
+@param title The overall title of the matrix to be formatted.
+@param aggr the aggregation functions to be applied to columns, rows.
+@return the matrix converted to a string.
+@see hep.aida.bin.BinFunction1D
+@see hep.aida.bin.BinFunctions1D
+
+public String toTitleString(DoubleMatrix3D matrix, String[] sliceNames, String[] rowNames, String[] columnNames, String sliceAxisName, String rowAxisName, String columnAxisName, String title, hep.aida.bin.BinFunction1D[] aggr) {
+	if (matrix.size()==0) return "Empty matrix";
+	StringBuffer buf = new StringBuffer();
+	for (int i=0; i<matrix.slices(); i++) {
+		if (i!=0) buf.append(sliceSeparator);
+		buf.append(toTitleString(matrix.viewSlice(i),rowNames,columnNames,rowAxisName,columnAxisName,title+"\n"+sliceAxisName+"="+sliceNames[i],aggr));
+	}
+	return buf.toString();
+}
+*/
+/**
+Returns a string representation of the given matrix with axis as well as rows and columns labeled.
+Pass <tt>null</tt> to one or more parameters to indicate that the corresponding decoration element shall not appear in the string converted matrix.
+
+@param matrix The matrix to format.
+@param sliceNames The headers of all slices (to be put above each slice).
+@param rowNames The headers of all rows (to be put to the left of the matrix).
+@param columnNames The headers of all columns (to be put to above the matrix).
+@param sliceAxisName The label of the z-axis (to be put above each slice).
+@param rowAxisName The label of the y-axis.
+@param columnAxisName The label of the x-axis.
+@param title The overall title of the matrix to be formatted.
+@return the matrix converted to a string.
+*/
+private String xtoTitleString(DoubleMatrix3D matrix, String[] sliceNames, String[] rowNames, String[] columnNames, String sliceAxisName, String rowAxisName, String columnAxisName, String title) {
+	if (matrix.size()==0) return "Empty matrix";
+	StringBuffer buf = new StringBuffer();
+	for (int i=0; i<matrix.slices(); i++) {
+		if (i!=0) buf.append(sliceSeparator);
+		buf.append(toTitleString(matrix.viewSlice(i),rowNames,columnNames,rowAxisName,columnAxisName,title+"\n"+sliceAxisName+"="+sliceNames[i]));
+	}
+	return buf.toString();
+}
+}

Propchange: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Formatter.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Partitioning.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Partitioning.java?rev=883365&view=auto
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Partitioning.java (added)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Partitioning.java Mon Nov 23 15:14:26 2009
@@ -0,0 +1,391 @@
+/*
+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.colt.matrix.doublealgo;
+
+import org.apache.mahout.colt.Swapper;
+import org.apache.mahout.colt.function.IntComparator;
+import org.apache.mahout.colt.matrix.DoubleMatrix1D;
+import org.apache.mahout.colt.matrix.DoubleMatrix2D;
+/**
+ * Given some interval boundaries, partitions matrices such that cell values falling into an interval are placed next to each other.
+ * <p>
+ * <b>Performance</b>
+ * <p>
+ * Partitioning into two intervals is <tt>O( N )</tt>.
+ * Partitioning into k intervals is <tt>O( N * log(k))</tt>.
+ * Constants factors are minimized. 
+ *
+ * @see org.apache.mahout.colt.Partitioning "Partitioning arrays (provides more documentation)"
+ *
+ * @author wolfgang.hoschek@cern.ch
+ * @version 1.0, 09/24/99
+ */
+/** 
+ * @deprecated until unit tests are in place.  Until this time, this class/interface is unsupported.
+ */
+@Deprecated
+public class Partitioning extends Object {
+/**
+ * Makes this class non instantiable, but still let's others inherit from it.
+ */
+protected Partitioning() {}
+/**
+Same as {@link org.apache.mahout.colt.Partitioning#partition(int[],int,int,int[],int,int,int[])}
+except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
+This is essentially the same as partitioning a list of composite objects by some instance variable;
+In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
+<p>
+Let's say, a "row" is an "object" (tuple, d-dimensional point).
+A "column" is the list of "object" values of a given variable (field, dimension).
+A "matrix" is a list of "objects" (tuples, points).
+<p>
+Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
+Two entire rows of the matrix are swapped, whenever two column values indicate so.
+<p>
+Note that arguments are not checked for validity.
+<p>
+<b>Example:</b> 
+<table border="1" cellspacing="0">
+  <tr nowrap> 
+	<td valign="top"><tt>8 x 3 matrix:<br>
+	  23, 22, 21<br>
+	  20, 19, 18<br>
+	  17, 16, 15<br>
+	  14, 13, 12<br>
+	  11, 10, 9<br>
+	  8,  7,  6<br>
+	  5,  4,  3<br>
+	  2,  1,  0 </tt></td>
+	<td align="left" valign="top"> 
+	  <p><tt>column = 0;<br>
+	    rowIndexes = {0,1,2,..,matrix.rows()-1};
+		rowFrom = 0;<br>
+		rowTo = matrix.rows()-1;<br>
+		splitters = {5,10,12}<br>
+		c = 0; <br>
+		d = splitters.length-1;<br>
+		partition(matrix,rowIndexes,rowFrom,rowTo,column,splitters,c,d,splitIndexes);<br>
+		==><br>
+		splitIndexes == {0, 2, 3}<br>
+		rowIndexes == {7, 6, 5, 4, 0, 1, 2, 3}</tt></p>
+	  </td>
+	<td valign="top">
+	  The matrix IS NOT REORDERED.<br>
+	  Here is how it would look<br>
+	  like, if it would be reordered<br>
+	  accoring to <tt>rowIndexes</tt>.<br>
+	  <tt>8 x 3 matrix:<br>
+	  2,  1,  0<br>
+	  5,  4,  3<br>
+	  8,  7,  6<br>
+	  11, 10, 9<br>
+	  23, 22, 21<br>
+	  20, 19, 18<br>
+	  17, 16, 15<br>
+	  14, 13, 12 </tt></td>
+  </tr>
+</table>
+@param matrix the matrix to be partitioned.
+@param rowIndexes the index of the i-th row; is modified by this method to reflect partitioned indexes.
+@param rowFrom the index of the first row (inclusive).
+@param rowTo the index of the last row (inclusive).
+@param column the index of the column to partition on.
+@param splitters the values at which the rows shall be split into intervals.
+	Must be sorted ascending and must not contain multiple identical values.
+	These preconditions are not checked; be sure that they are met.
+ 
+@param splitFrom the index of the first splitter element to be considered.
+@param splitTo the index of the last splitter element to be considered.
+	The method considers the splitter elements <tt>splitters[splitFrom] .. splitters[splitTo]</tt>.
+ 
+@param splitIndexes a list into which this method fills the indexes of rows delimiting intervals.
+Upon return <tt>splitIndexes[splitFrom..splitTo]</tt> will be set accordingly.
+Therefore, must satisfy <tt>splitIndexes.length >= splitters.length</tt>.
+*/
+public static void partition(DoubleMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column, final double[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
+	if (rowFrom < 0 || rowTo >= matrix.rows() || rowTo >= rowIndexes.length) throw new IllegalArgumentException();
+	if (column < 0 || column >= matrix.columns()) throw new IllegalArgumentException();
+	if (splitFrom < 0 || splitTo >= splitters.length) throw new IllegalArgumentException();
+	if (splitIndexes.length < splitters.length) throw new IllegalArgumentException();
+
+	// this one knows how to swap two row indexes (a,b)
+	final int[] g = rowIndexes;
+	Swapper swapper = new Swapper() {
+		public void swap(int b, int c) {
+			int tmp = g[b]; g[b] = g[c]; g[c] = tmp;
+		}
+	};
+	
+	// compare splitter[a] with columnView[rowIndexes[b]]
+	final DoubleMatrix1D columnView = matrix.viewColumn(column);	
+	IntComparator comp = new IntComparator() {
+		public int compare(int a, int b) {
+			double av = splitters[a];
+			double bv = columnView.getQuick(g[b]);
+			return av<bv ? -1 : (av==bv ? 0 : 1);
+		}
+	};
+
+	// compare columnView[rowIndexes[a]] with columnView[rowIndexes[b]]
+	IntComparator comp2 = new IntComparator() {
+		public int compare(int a, int b) {
+			double av = columnView.getQuick(g[a]);
+			double bv = columnView.getQuick(g[b]);
+			return av<bv ? -1 : (av==bv ? 0 : 1);
+		}
+	};
+
+	// compare splitter[a] with splitter[b]
+	IntComparator comp3 = new IntComparator() {
+		public int compare(int a, int b) {
+			double av = splitters[a];
+			double bv = splitters[b];
+			return av<bv ? -1 : (av==bv ? 0 : 1);
+		}
+	};
+
+	// generic partitioning does the main work of reordering row indexes
+	org.apache.mahout.colt.Partitioning.genericPartition(rowFrom,rowTo,splitFrom,splitTo,splitIndexes,comp,comp2,comp3,swapper);
+}
+/**
+Same as {@link org.apache.mahout.colt.Partitioning#partition(int[],int,int,int[],int,int,int[])}
+except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
+This is essentially the same as partitioning a list of composite objects by some instance variable;
+In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
+<p>
+Let's say, a "row" is an "object" (tuple, d-dimensional point).
+A "column" is the list of "object" values of a given variable (field, dimension).
+A "matrix" is a list of "objects" (tuples, points).
+<p>
+Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
+Two entire rows of the matrix are swapped, whenever two column values indicate so.
+<p>
+Note that arguments are not checked for validity.
+<p>
+<b>Example:</b> 
+<table border="1" cellspacing="0">
+  <tr nowrap> 
+	<td valign="top"><tt>8 x 3 matrix:<br>
+	  23, 22, 21<br>
+	  20, 19, 18<br>
+	  17, 16, 15<br>
+	  14, 13, 12<br>
+	  11, 10, 9<br>
+	  8,  7,  6<br>
+	  5,  4,  3<br>
+	  2,  1,  0 </tt></td>
+	<td align="left" valign="top"> 
+	    <tt>column = 0;<br>
+		splitters = {5,10,12}<br>
+		partition(matrix,column,splitters,splitIndexes);<br>
+		==><br>
+		splitIndexes == {0, 2, 3}</tt></p>
+	  </td>
+	<td valign="top">
+	  The matrix IS NOT REORDERED.<br>
+	  The new VIEW IS REORDERED:<br>
+	  <tt>8 x 3 matrix:<br>
+	  2,  1,  0<br>
+	  5,  4,  3<br>
+	  8,  7,  6<br>
+	  11, 10, 9<br>
+	  23, 22, 21<br>
+	  20, 19, 18<br>
+	  17, 16, 15<br>
+	  14, 13, 12 </tt></td>
+  </tr>
+</table>
+@param matrix the matrix to be partitioned.
+@param column the index of the column to partition on.
+@param splitters the values at which the rows shall be split into intervals.
+	Must be sorted ascending and must not contain multiple identical values.
+	These preconditions are not checked; be sure that they are met.
+ 
+@param splitIndexes a list into which this method fills the indexes of rows delimiting intervals.
+Therefore, must satisfy <tt>splitIndexes.length >= splitters.length</tt>.
+
+@return a new matrix view having rows partitioned by the given column and splitters.
+*/
+public static DoubleMatrix2D partition(DoubleMatrix2D matrix, int column, final double[] splitters, int[] splitIndexes) {
+	int rowFrom = 0;
+	int rowTo = matrix.rows()-1;
+	int splitFrom = 0;
+	int splitTo = splitters.length-1;
+	int[] rowIndexes = new int[matrix.rows()]; // row indexes to reorder instead of matrix itself
+	for (int i=rowIndexes.length; --i >= 0; ) rowIndexes[i] = i;
+
+	partition(matrix,rowIndexes,rowFrom,rowTo,column,splitters,splitFrom,splitTo,splitIndexes);
+
+	// take all columns in the original order
+	int[] columnIndexes = new int[matrix.columns()];
+	for (int i=columnIndexes.length; --i >= 0; ) columnIndexes[i] = i;
+
+	// view the matrix according to the reordered row indexes
+	return matrix.viewSelection(rowIndexes,columnIndexes);
+}
+/**
+Same as {@link #partition(int[],int,int,int[],int,int,int[])}
+except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
+This is essentially the same as partitioning a list of composite objects by some instance variable;
+In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
+<p>
+Let's say, a "row" is an "object" (tuple, d-dimensional point).
+A "column" is the list of "object" values of a given variable (field, dimension).
+A "matrix" is a list of "objects" (tuples, points).
+<p>
+Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
+Two entire rows of the matrix are swapped, whenever two column values indicate so.
+<p>
+Of course, the column must not be a column of a different matrix.
+More formally, there must hold: <br>
+There exists an <tt>i</tt> such that <tt>matrix.viewColumn(i)==column</tt>.
+<p>
+Note that arguments are not checked for validity.
+<p>
+<b>Example:</b> 
+<table border="1" cellspacing="0">
+  <tr nowrap> 
+	<td valign="top"><tt>8 x 3 matrix:<br>
+	  23, 22, 21<br>
+	  20, 19, 18<br>
+	  17, 16, 15<br>
+	  14, 13, 12<br>
+	  11, 10, 9<br>
+	  8,  7,  6<br>
+	  5,  4,  3<br>
+	  2,  1,  0 </tt></td>
+	<td align="left"> 
+	  <p><tt>column = matrix.viewColumn(0);<br>
+		a = 0;<br>
+		b = column.size()-1;</tt><tt><br>
+		splitters={5,10,12}<br>
+		c=0; <br>
+		d=splitters.length-1;</tt><tt><br>
+		partition(matrix,column,a,b,splitters,c,d,splitIndexes);<br>
+		==><br>
+		splitIndexes == {0, 2, 3}</tt></p>
+	  </td>
+	<td valign="top"><tt>8 x 3 matrix:<br>
+	  2,  1,  0<br>
+	  5,  4,  3<br>
+	  8,  7,  6<br>
+	  11, 10, 9<br>
+	  23, 22, 21<br>
+	  20, 19, 18<br>
+	  17, 16, 15<br>
+	  14, 13, 12 </tt></td>
+  </tr>
+</table>
+*/
+private static void xPartitionOld(DoubleMatrix2D matrix, DoubleMatrix1D column, int from, int to, double[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
+	/*
+	double splitter; // int, double --> template type dependent
+	
+	if (splitFrom>splitTo) return; // nothing to do
+	if (from>to) { // all bins are empty
+		from--;
+		for (int i = splitFrom; i<=splitTo; ) splitIndexes[i++] = from;
+		return;
+	}
+	
+	// Choose a partition (pivot) index, m
+	// Ideally, the pivot should be the median, because a median splits a list into two equal sized sublists.
+	// However, computing the median is expensive, so we use an approximation.
+	int medianIndex;
+	if (splitFrom==splitTo) { // we don't really have a choice
+		medianIndex = splitFrom;
+	}
+	else { // we do have a choice
+		int m = (from+to) / 2;       // Small arrays, middle element
+		int len = to-from+1;
+		if (len > SMALL) {
+		    int l = from;
+		    int n = to;
+		    if (len > MEDIUM) {        // Big arrays, pseudomedian of 9
+				int s = len/8;
+				l = med3(column, l,     l+s, l+2*s);
+				m = med3(column, m-s,   m,   m+s);
+				n = med3(column, n-2*s, n-s, n);
+		    }
+		    m = med3(column, l, m, n); // Mid-size, pseudomedian of 3
+		}
+		
+		// Find the splitter closest to the pivot, i.e. the splitter that best splits the list into two equal sized sublists.
+		medianIndex = org.apache.mahout.colt.Sorting.binarySearchFromTo(splitters,column.getQuick(m),splitFrom,splitTo);
+		if (medianIndex < 0) medianIndex = -medianIndex - 1; // not found
+		if (medianIndex > splitTo) medianIndex = splitTo; // not found, one past the end
+		
+	}
+	splitter = splitters[medianIndex];
+
+	// Partition the list according to the splitter, i.e.
+	// Establish invariant: list[i] < splitter <= list[j] for i=from..medianIndex and j=medianIndex+1 .. to
+	int	splitIndex = xPartitionOld(matrix,column,from,to,splitter);
+	splitIndexes[medianIndex] = splitIndex;
+
+	// Optimization: Handle special cases to cut down recursions.
+	if (splitIndex < from) { // no element falls into this bin
+		// all bins with splitters[i] <= splitter are empty
+		int i = medianIndex-1;
+		while (i>=splitFrom && (!(splitter < splitters[i]))) splitIndexes[i--] = splitIndex;
+		splitFrom = medianIndex+1;
+	}
+	else if (splitIndex >= to) { // all elements fall into this bin
+		// all bins with splitters[i] >= splitter are empty
+		int i = medianIndex+1;
+		while (i<=splitTo && (!(splitter > splitters[i]))) splitIndexes[i++] = splitIndex;
+		splitTo = medianIndex-1;
+	}
+
+	// recursively partition left half
+	if (splitFrom <= medianIndex-1) {
+		xPartitionOld(matrix, column, from,         splitIndex, splitters, splitFrom, medianIndex-1,  splitIndexes);
+	}
+	
+	// recursively partition right half
+	if (medianIndex+1 <= splitTo) {
+		xPartitionOld(matrix, column, splitIndex+1, to,         splitters, medianIndex+1,  splitTo,   splitIndexes);
+	}
+	*/
+}
+/**
+ * Same as {@link #partition(int[],int,int,int)} 
+ * except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
+ * This is essentially the same as partitioning a list of composite objects by some instance variable;
+ * In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
+ * <p>
+ * Let's say, a "row" is an "object" (tuple, d-dimensional point).
+ * A "column" is the list of "object" values of a given variable (field, dimension).
+ * A "matrix" is a list of "objects" (tuples, points).
+ * <p>
+ * Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
+ * Two entire rows of the matrix are swapped, whenever two column values indicate so.
+ * <p>
+ * Of course, the column must not be a column of a different matrix.
+ * More formally, there must hold: <br>
+ * There exists an <tt>i</tt> such that <tt>matrix.viewColumn(i)==column</tt>.
+ *
+ * Note that arguments are not checked for validity.
+ */
+private static int xPartitionOld(DoubleMatrix2D matrix, DoubleMatrix1D column, int from, int to, double splitter) {
+	/*
+	double element;  // int, double --> template type dependent
+	for (int i=from-1; ++i<=to; ) {
+		element = column.getQuick(i);
+		if (element < splitter) {
+			// swap x[i] with x[from]
+			matrix.swapRows(i,from);
+			from++;
+		}
+	}
+	return from-1;
+	*/
+	return 0;
+}
+}

Propchange: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/doublealgo/Partitioning.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message