You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mahout.apache.org by sr...@apache.org on 2009/11/29 12:20:11 UTC
svn commit: r885213 [6/6] - in
/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout: jet/math/
jet/random/ jet/random/engine/ jet/random/sampling/ jet/stat/
jet/stat/quantile/ matrix/ matrix/bitvector/ matrix/buffer/ matrix/list/
matrix/list/ada...
Modified: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/linalg/SmpBlas.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/linalg/SmpBlas.java?rev=885213&r1=885212&r2=885213&view=diff
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/linalg/SmpBlas.java (original)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/linalg/SmpBlas.java Sun Nov 29 11:19:58 2009
@@ -67,13 +67,13 @@
*/
private static Blas smpBlas = SeqBlas.seqBlas;
- protected final Blas seqBlas; // blocks are operated on in parallel; for each block this seq algo is used.
+ private final Blas seqBlas; // blocks are operated on in parallel; for each block this seq algo is used.
- protected final Smp smp;
+ private final Smp smp;
- protected final int maxThreads;
+ private final int maxThreads;
- protected static final int NN_THRESHOLD = 30000;
+ private static final int NN_THRESHOLD = 30000;
public static Blas getSmpBlas() {
return smpBlas;
@@ -448,20 +448,4 @@
}
}
- private double xsum(DoubleMatrix2D A) {
- double[] sums = run(A, true,
- new Matrix2DMatrix2DFunction() {
- @Override
- public double apply(DoubleMatrix2D AA, DoubleMatrix2D BB) {
- return AA.zSum();
- }
- }
- );
-
- double sum = 0;
- for (int i = sums.length; --i >= 0;) {
- sum += sums[i];
- }
- return sum;
- }
}
Modified: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Formatter.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Formatter.java?rev=885213&r1=885212&r2=885213&view=diff
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Formatter.java (original)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Formatter.java Sun Nov 29 11:19:58 2009
@@ -209,7 +209,7 @@
int width = c + columns;
// make larger matrix holding original matrix and naming strings
- org.apache.mahout.matrix.matrix.ObjectMatrix2D titleMatrix = matrix.like(height, width);
+ ObjectMatrix2D titleMatrix = matrix.like(height, width);
// insert original matrix into larger matrix
titleMatrix.viewPart(r, c, rows, columns).assign(matrix);
Modified: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Partitioning.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Partitioning.java?rev=885213&r1=885212&r2=885213&view=diff
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Partitioning.java (original)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Partitioning.java Sun Nov 29 11:19:58 2009
@@ -30,7 +30,6 @@
@Deprecated
public class Partitioning {
- /** Makes this class non instantiable, but still let's others inherit from it. */
private Partitioning() {
}
@@ -68,7 +67,7 @@
* <tt>splitIndexes[splitFrom..splitTo]</tt> will be set accordingly. Therefore, must satisfy
* <tt>splitIndexes.length >= splitters.length</tt>.
*/
- public static void partition(ObjectMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column,
+ private static void partition(ObjectMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column,
final Object[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
if (rowFrom < 0 || rowTo >= matrix.rows() || rowTo >= rowIndexes.length) {
throw new IllegalArgumentException();
@@ -129,8 +128,8 @@
};
// generic partitioning does the main work of reordering row indexes
- org.apache.mahout.matrix.Partitioning
- .genericPartition(rowFrom, rowTo, splitFrom, splitTo, splitIndexes, comp, comp2, comp3, swapper);
+ org.apache.mahout.matrix.Partitioning.genericPartition(
+ rowFrom, rowTo, splitFrom, splitTo, splitIndexes, comp, comp2, comp3, swapper);
}
/**
@@ -180,122 +179,4 @@
return matrix.viewSelection(rowIndexes, columnIndexes);
}
- /**
- * Same 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(ObjectMatrix2D matrix, ObjectMatrix1D column, int from, int to, Object[] splitters,
- int splitFrom, int splitTo, int[] splitIndexes) {
- /*
- Object splitter; // int, Object --> 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.matrix.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 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(ObjectMatrix2D matrix, ObjectMatrix1D column, int from, int to, Object splitter) {
- /*
- Object element; // int, Object --> 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;
- }
}
Modified: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Sorting.java
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Sorting.java?rev=885213&r1=885212&r2=885213&view=diff
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Sorting.java (original)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/objectalgo/Sorting.java Sun Nov 29 11:19:58 2009
@@ -8,6 +8,8 @@
*/
package org.apache.mahout.matrix.matrix.objectalgo;
+import org.apache.mahout.matrix.GenericSorting;
+import org.apache.mahout.matrix.PersistentObject;
import org.apache.mahout.matrix.function.IntComparator;
import org.apache.mahout.matrix.matrix.ObjectMatrix1D;
import org.apache.mahout.matrix.matrix.ObjectMatrix2D;
@@ -42,7 +44,7 @@
/** @deprecated until unit tests are in place. Until this time, this class/interface is unsupported. */
@Deprecated
-public class Sorting extends org.apache.mahout.matrix.PersistentObject {
+public class Sorting extends PersistentObject {
/** A prefabricated quicksort. */
public static final Sorting quickSort = new Sorting(); // already has quicksort implemented
@@ -57,20 +59,20 @@
@Override
protected void runSort(int fromIndex, int toIndex, IntComparator c, org.apache.mahout.matrix.Swapper swapper) {
- org.apache.mahout.matrix.GenericSorting.mergeSort(fromIndex, toIndex, c, swapper);
+ GenericSorting.mergeSort(fromIndex, toIndex, c, swapper);
}
};
/** Makes this class non instantiable, but still let's others inherit from it. */
- protected Sorting() {
+ private Sorting() {
}
- protected void runSort(int[] a, int fromIndex, int toIndex, IntComparator c) {
+ private void runSort(int[] a, int fromIndex, int toIndex, IntComparator c) {
org.apache.mahout.matrix.Sorting.quickSort(a, fromIndex, toIndex, c);
}
protected void runSort(int fromIndex, int toIndex, IntComparator c, org.apache.mahout.matrix.Swapper swapper) {
- org.apache.mahout.matrix.GenericSorting.quickSort(fromIndex, toIndex, c, swapper);
+ GenericSorting.quickSort(fromIndex, toIndex, c, swapper);
}
/**
@@ -148,9 +150,9 @@
* matrix, and vice-versa. To sort ranges use sub-ranging views. To sort columns by rows, use dice views. To sort
* descending, use flip views ... <p> <b>Example:</b> <table border="1" cellspacing="0"> <tr nowrap> <td
* valign="top"><tt>4 x 2 matrix: <br> 7, 6<br> 5, 4<br> 3, 2<br> 1, 0 <br> </tt></td> <td align="left" valign="top">
- * <p><tt>column = 0;<br> view = quickSort(matrix,column);<br> log.info(view); </tt><tt><br> ==> </tt></p>
- * </td> <td valign="top"> <p><tt>4 x 2 matrix:<br> 1, 0<br> 3, 2<br> 5, 4<br> 7, 6</tt><br> The matrix IS NOT
- * SORTED.<br> The new VIEW IS SORTED.</p> </td> </tr> </table>
+ * <p><tt>column = 0;<br> view = quickSort(matrix,column);<br> log.info(view); </tt><tt><br> ==> </tt></p> </td> <td
+ * valign="top"> <p><tt>4 x 2 matrix:<br> 1, 0<br> 3, 2<br> 5, 4<br> 7, 6</tt><br> The matrix IS NOT SORTED.<br> The
+ * new VIEW IS SORTED.</p> </td> </tr> </table>
*
* @param matrix the matrix to be sorted.
* @param column the index of the column inducing the order.
Modified: lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/package.html
URL: http://svn.apache.org/viewvc/lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/package.html?rev=885213&r1=885212&r2=885213&view=diff
==============================================================================
--- lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/package.html (original)
+++ lucene/mahout/trunk/matrix/src/main/java/org/apache/mahout/matrix/matrix/package.html Sun Nov 29 11:19:58 2009
@@ -564,7 +564,7 @@
{@link org.apache.mahout.matrix.matrix.DoubleMatrix2D}). Note that looking at the documentation
of some concrete instantiable class (e.g. {@link org.apache.mahout.matrix.matrix.impl.DenseDoubleMatrix2D},
{@link org.apache.mahout.matrix.matrix.impl.SparseDoubleMatrix2D}, {@link
- org.apache.mahout.matrix.matrix.impl.RCDoubleMatrix2D}<img
+ impl.RCDoubleMatrix2D}<img
src="../doc-files/new.gif" width="32" height="22" align="top">)
will not reveal more information than can be obtained by looking at the abstract
base classes. The convention is that concrete classes <i>do no subsetting or
@@ -666,7 +666,7 @@
<p>Class naming for concrete instantiable classes follows the schema <tt><Property><ValueType>Matrix<Rank>D</tt>.
For example, we have a {@link org.apache.mahout.matrix.matrix.impl.DenseDoubleMatrix2D}, a
{@link org.apache.mahout.matrix.matrix.impl.SparseDoubleMatrix2D}, a {@link
- org.apache.mahout.matrix.matrix.impl.DenseIntMatrix3D},
+ impl.DenseIntMatrix3D},
and so on. All concrete instantiable classes are separated into an extra package,
{@link org.apache.mahout.matrix.matrix.impl}, to clearly distinguish between interfaces and
implementations.</p>