You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mahout.apache.org by td...@apache.org on 2011/09/01 13:29:31 UTC
svn commit: r1164016 [1/2] - in /mahout/trunk:
core/src/main/java/org/apache/mahout/cf/taste/hadoop/als/eval/
core/src/main/java/org/apache/mahout/classifier/bayes/
core/src/main/java/org/apache/mahout/classifier/discriminative/
core/src/main/java/org/...
Author: tdunning
Date: Thu Sep 1 11:29:29 2011
New Revision: 1164016
URL: http://svn.apache.org/viewvc?rev=1164016&view=rev
Log:
MAHOUT-790 - kill the cardinality array and size() for matrices. Use rowSize() and columnSize() instead.
MAHOUT-792 - Fix RTM to avoid size() and cardinality array.
Added:
mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomTrinaryMatrix.java
Modified:
mahout/trunk/core/src/main/java/org/apache/mahout/cf/taste/hadoop/als/eval/InMemoryFactorizationEvaluator.java
mahout/trunk/core/src/main/java/org/apache/mahout/classifier/bayes/InMemoryBayesDatastore.java
mahout/trunk/core/src/main/java/org/apache/mahout/classifier/discriminative/LinearTrainer.java
mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/NaiveBayesModel.java
mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/training/TrainUtils.java
mahout/trunk/core/src/main/java/org/apache/mahout/classifier/sequencelearning/hmm/HmmUtils.java
mahout/trunk/core/src/main/java/org/apache/mahout/math/MatrixWritable.java
mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/decomposer/EigenVerificationJob.java
mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/stochasticsvd/UpperTriangular.java
mahout/trunk/core/src/test/java/org/apache/mahout/cf/taste/hadoop/als/ParallelALSFactorizationJobTest.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/AbstractMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/DenseMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/DiagonalMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/Matrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/MatrixView.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/PermutedVectorView.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/PivotedMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomAccessSparseVector.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/SequentialAccessSparseVector.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseColumnMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseRowMatrix.java
mahout/trunk/math/src/main/java/org/apache/mahout/math/decomposer/hebbian/HebbianSolver.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/AbstractTestVector.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/MatrixTest.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/TestMatrixView.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/TestSparseColumnMatrix.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/TestSparseMatrix.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/TestSparseRowMatrix.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/TestVectorView.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/als/AlternateLeastSquaresSolverTest.java
mahout/trunk/math/src/test/java/org/apache/mahout/math/decomposer/SolverTest.java
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/cf/taste/hadoop/als/eval/InMemoryFactorizationEvaluator.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/cf/taste/hadoop/als/eval/InMemoryFactorizationEvaluator.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/cf/taste/hadoop/als/eval/InMemoryFactorizationEvaluator.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/cf/taste/hadoop/als/eval/InMemoryFactorizationEvaluator.java Thu Sep 1 11:29:29 2011
@@ -116,7 +116,7 @@ public class InMemoryFactorizationEvalua
private Matrix readMatrix(Path dir) throws IOException {
- Matrix matrix = new SparseMatrix(new int[] { Integer.MAX_VALUE, Integer.MAX_VALUE });
+ Matrix matrix = new SparseMatrix(Integer.MAX_VALUE, Integer.MAX_VALUE);
FileSystem fs = dir.getFileSystem(getConf());
for (FileStatus seqFile : fs.globStatus(new Path(dir, "part-*"))) {
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/classifier/bayes/InMemoryBayesDatastore.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/classifier/bayes/InMemoryBayesDatastore.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/classifier/bayes/InMemoryBayesDatastore.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/classifier/bayes/InMemoryBayesDatastore.java Thu Sep 1 11:29:29 2011
@@ -45,7 +45,7 @@ public class InMemoryBayesDatastore impl
private final OpenIntDoubleHashMap thetaNormalizerPerLabel = new OpenIntDoubleHashMap();
- private final Matrix weightMatrix = new SparseMatrix(new int[] {1, 0});
+ private final Matrix weightMatrix = new SparseMatrix(1, 0);
private final BayesParameters params;
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/classifier/discriminative/LinearTrainer.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/classifier/discriminative/LinearTrainer.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/classifier/discriminative/LinearTrainer.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/classifier/discriminative/LinearTrainer.java Thu Sep 1 11:29:29 2011
@@ -73,8 +73,8 @@ public abstract class LinearTrainer {
* thrown
*/
public void train(Vector labelset, Matrix dataset) throws TrainingException {
- if (labelset.size() != dataset.size()[1]) {
- throw new CardinalityException(labelset.size(), dataset.size()[1]);
+ if (labelset.size() != dataset.columnSize()) {
+ throw new CardinalityException(labelset.size(), dataset.columnSize());
}
boolean converged = false;
@@ -85,7 +85,7 @@ public abstract class LinearTrainer {
}
converged = true;
- int columnCount = dataset.size()[1];
+ int columnCount = dataset.columnSize();
for (int i = 0; i < columnCount; i++) {
Vector dataPoint = dataset.viewColumn(i);
log.debug("Training point: " + dataPoint);
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/NaiveBayesModel.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/NaiveBayesModel.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/NaiveBayesModel.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/NaiveBayesModel.java Thu Sep 1 11:29:29 2011
@@ -108,7 +108,7 @@ public class NaiveBayesModel {
weightsPerLabel = VectorWritable.readVector(in);
perLabelThetaNormalizer = VectorWritable.readVector(in);
- weightsPerLabelAndFeature = new SparseMatrix(new int[] { weightsPerLabel.size(), weightsPerFeature.size() });
+ weightsPerLabelAndFeature = new SparseMatrix(weightsPerLabel.size(), weightsPerFeature.size() );
for (int label = 0; label < weightsPerLabelAndFeature.numRows(); label++) {
weightsPerLabelAndFeature.assignRow(label, VectorWritable.readVector(in));
}
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/training/TrainUtils.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/training/TrainUtils.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/training/TrainUtils.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/classifier/naivebayes/training/TrainUtils.java Thu Sep 1 11:29:29 2011
@@ -69,7 +69,7 @@ public class TrainUtils {
Preconditions.checkNotNull(scoresPerFeature);
Preconditions.checkNotNull(scoresPerLabel);
- Matrix scoresPerLabelAndFeature = new SparseMatrix(new int[]{scoresPerLabel.size(), scoresPerFeature.size()});
+ Matrix scoresPerLabelAndFeature = new SparseMatrix(scoresPerLabel.size(), scoresPerFeature.size());
for (Pair<IntWritable,VectorWritable> entry : new SequenceFileDirIterable<IntWritable,VectorWritable>(
new Path(base, TrainNaiveBayesJob.SUMMED_OBSERVATIONS), PathType.LIST, PathFilters.partFilter(), conf)) {
scoresPerLabelAndFeature.assignRow(entry.getFirst().get(), entry.getSecond().get());
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/classifier/sequencelearning/hmm/HmmUtils.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/classifier/sequencelearning/hmm/HmmUtils.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/classifier/sequencelearning/hmm/HmmUtils.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/classifier/sequencelearning/hmm/HmmUtils.java Thu Sep 1 11:29:29 2011
@@ -327,10 +327,8 @@ public final class HmmUtils {
// allocate the sparse data structures
RandomAccessSparseVector sparseIp = new RandomAccessSparseVector(model
.getNrOfHiddenStates());
- SparseMatrix sparseEm = new SparseMatrix(new int[]{
- model.getNrOfHiddenStates(), model.getNrOfOutputStates()});
- SparseMatrix sparseTr = new SparseMatrix(new int[]{
- model.getNrOfHiddenStates(), model.getNrOfHiddenStates()});
+ SparseMatrix sparseEm = new SparseMatrix(model.getNrOfHiddenStates(), model.getNrOfOutputStates());
+ SparseMatrix sparseTr = new SparseMatrix(model.getNrOfHiddenStates(), model.getNrOfHiddenStates());
// now transfer the values
for (int i = 0; i < model.getNrOfHiddenStates(); ++i) {
double value = ip.getQuick(i);
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/math/MatrixWritable.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/math/MatrixWritable.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/math/MatrixWritable.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/math/MatrixWritable.java Thu Sep 1 11:29:29 2011
@@ -111,7 +111,7 @@ public class MatrixWritable implements W
if (dense) {
r = new DenseMatrix(rows, columns);
} else {
- r = new SparseRowMatrix(new int[]{rows, columns}, !sequential);
+ r = new SparseRowMatrix(rows, columns, !sequential);
}
for (int row = 0; row < rows; row++) {
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/decomposer/EigenVerificationJob.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/decomposer/EigenVerificationJob.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/decomposer/EigenVerificationJob.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/decomposer/EigenVerificationJob.java Thu Sep 1 11:29:29 2011
@@ -263,7 +263,7 @@ public class EigenVerificationJob extend
for (MatrixSlice slice : eigens) {
eigenVectors.add(slice.vector());
}
- eigensToVerify = new SparseRowMatrix(new int[] {eigenVectors.size(), eigenVectors.get(0).size()},
+ eigensToVerify = new SparseRowMatrix(eigenVectors.size(), eigenVectors.get(0).size(),
eigenVectors.toArray(new Vector[eigenVectors.size()]),
true,
true);
Modified: mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/stochasticsvd/UpperTriangular.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/stochasticsvd/UpperTriangular.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/stochasticsvd/UpperTriangular.java (original)
+++ mahout/trunk/core/src/main/java/org/apache/mahout/math/hadoop/stochasticsvd/UpperTriangular.java Thu Sep 1 11:29:29 2011
@@ -43,14 +43,21 @@ public class UpperTriangular extends Abs
*/
public UpperTriangular(int n) {
+ super(n, n);
values = new double[n * (n + 1) / 2];
this.n = n;
- cardinality[0] = cardinality[1] = n;
}
public UpperTriangular(Vector data) {
- n = (int) Math.round((-1 + Math.sqrt(1 + 8 * data.size())) / 2);
- cardinality[0] = cardinality[1] = n;
+ this((int) Math.round((-1 + Math.sqrt(1 + 8 * data.size())) / 2), data);
+ }
+
+ public UpperTriangular(double[] data, boolean shallow) {
+ this((int) Math.round((-1 + Math.sqrt(1 + 8 * data.length)) / 2), data, shallow);
+ }
+
+ private UpperTriangular(int rows, Vector data) {
+ super(rows, rows);
values = new double[n * (n + 1) / 2];
int n = data.size();
// if ( data instanceof DenseVector )
@@ -62,13 +69,12 @@ public class UpperTriangular extends Abs
}
}
- public UpperTriangular(double[] data, boolean shallow) {
+ private UpperTriangular(int rows, double[] data, boolean shallow) {
+ super(rows, rows);
if (data == null) {
throw new IllegalArgumentException("data");
}
values = shallow ? data : data.clone();
- n = (int) Math.round((-1 + Math.sqrt(1 + 8 * data.length)) / 2);
- cardinality[0] = cardinality[1] = n;
}
// copy-constructor
@@ -78,7 +84,6 @@ public class UpperTriangular extends Abs
@Override
public Matrix assignColumn(int column, Vector other) {
-
throw new UnsupportedOperationException();
}
Modified: mahout/trunk/core/src/test/java/org/apache/mahout/cf/taste/hadoop/als/ParallelALSFactorizationJobTest.java
URL: http://svn.apache.org/viewvc/mahout/trunk/core/src/test/java/org/apache/mahout/cf/taste/hadoop/als/ParallelALSFactorizationJobTest.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/core/src/test/java/org/apache/mahout/cf/taste/hadoop/als/ParallelALSFactorizationJobTest.java (original)
+++ mahout/trunk/core/src/test/java/org/apache/mahout/cf/taste/hadoop/als/ParallelALSFactorizationJobTest.java Thu Sep 1 11:29:29 2011
@@ -214,7 +214,7 @@ public class ParallelALSFactorizationJob
File tmpDir = getTestTempDir("tmp");
Double na = Double.NaN;
- Matrix preferences = new SparseRowMatrix(new int[] { 4, 4 }, new Vector[] {
+ Matrix preferences = new SparseRowMatrix(4, 4, new Vector[] {
new DenseVector(new double[] {5.0, 5.0, 2.0, na }),
new DenseVector(new double[] {2.0, na, 3.0, 5.0 }),
new DenseVector(new double[] { na, 5.0, na, 3.0 }),
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/AbstractMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/AbstractMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/AbstractMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/AbstractMatrix.java Thu Sep 1 11:29:29 2011
@@ -35,21 +35,21 @@ public abstract class AbstractMatrix imp
protected Map<String, Integer> rowLabelBindings;
- protected int[] cardinality = new int[2];
+ protected int rows, columns;
- @Override
- public int columnSize() {
- return cardinality[COL];
+ public AbstractMatrix(int rows, int columns) {
+ this.rows = rows;
+ this.columns = columns;
}
@Override
- public int rowSize() {
- return cardinality[ROW];
+ public int columnSize() {
+ return columns;
}
@Override
- public int[] size() {
- return cardinality;
+ public int rowSize() {
+ return rows;
}
@Override
@@ -171,12 +171,12 @@ public abstract class AbstractMatrix imp
@Override
public int numRows() {
- return size()[ROW];
+ return rowSize();
}
@Override
public int numCols() {
- return size()[COL];
+ return columnSize();
}
@Override
@@ -186,9 +186,10 @@ public abstract class AbstractMatrix imp
@Override
public Matrix assign(double value) {
- int[] c = size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ int rows = rowSize();
+ int columns = columnSize();
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
setQuick(row, col, value);
}
}
@@ -197,17 +198,16 @@ public abstract class AbstractMatrix imp
@Override
public Matrix assign(double[][] values) {
- int[] c = size();
- if (c[ROW] != values.length) {
- throw new CardinalityException(c[ROW], values.length);
- }
- for (int row = 0; row < c[ROW]; row++) {
- if (c[COL] == values[row].length) {
- for (int col = 0; col < c[COL]; col++) {
+ if (rowSize() != values.length) {
+ throw new CardinalityException(rowSize(), values.length);
+ }
+ for (int row = 0; row < rowSize(); row++) {
+ if (columnSize() == values[row].length) {
+ for (int col = 0; col < columnSize(); col++) {
setQuick(row, col, values[row][col]);
}
} else {
- throw new CardinalityException(c[COL], values[row].length);
+ throw new CardinalityException(columnSize(), values[row].length);
}
}
return this;
@@ -215,16 +215,16 @@ public abstract class AbstractMatrix imp
@Override
public Matrix assign(Matrix other, DoubleDoubleFunction function) {
- int[] c = size();
- int[] o = other.size();
- if (c[ROW] != o[ROW]) {
- throw new CardinalityException(c[ROW], o[ROW]);
+ int rows = rowSize();
+ int columns = columnSize();
+ if (rows != other.rowSize()) {
+ throw new CardinalityException(rowSize(), other.rowSize());
}
- if (c[COL] != o[COL]) {
- throw new CardinalityException(c[COL], o[COL]);
+ if (columns != other.columnSize()) {
+ throw new CardinalityException(columnSize(), other.columnSize());
}
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
setQuick(row, col, function.apply(getQuick(row, col), other.getQuick(
row, col)));
}
@@ -234,16 +234,16 @@ public abstract class AbstractMatrix imp
@Override
public Matrix assign(Matrix other) {
- int[] c = size();
- int[] o = other.size();
- if (c[ROW] != o[ROW]) {
- throw new CardinalityException(c[ROW], o[ROW]);
+ int rows = rowSize();
+ int columns = columnSize();
+ if (rows != other.rowSize()) {
+ throw new CardinalityException(rowSize(), other.rowSize());
}
- if (c[COL] != o[COL]) {
- throw new CardinalityException(c[COL], o[COL]);
+ if (columns != other.columnSize()) {
+ throw new CardinalityException(columnSize(), other.columnSize());
}
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
setQuick(row, col, other.getQuick(row, col));
}
}
@@ -252,9 +252,10 @@ public abstract class AbstractMatrix imp
@Override
public Matrix assign(DoubleFunction function) {
- int[] c = size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ int rows = rowSize();
+ int columns = columnSize();
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
setQuick(row, col, function.apply(getQuick(row, col)));
}
}
@@ -307,21 +308,6 @@ public abstract class AbstractMatrix imp
}
/**
- * Collects the results of a function applied to each column of a matrix.
- *
- * @param f The function to be applied to each column.
- * @return The vector of results.
- */
- @Override
- public Vector aggregateColumns(VectorFunction f) {
- Vector r = new DenseVector(numCols());
- for (int col = 0; col < numCols(); col++) {
- r.set(col, f.apply(viewColumn(col)));
- }
- return r;
- }
-
- /**
* Collects the results of a function applied to each element of a matrix and then aggregated.
*
* @param combiner A function that combines the results of the mapper.
@@ -338,26 +324,40 @@ public abstract class AbstractMatrix imp
}).aggregate(combiner, Functions.IDENTITY);
}
+ /**
+ * Collects the results of a function applied to each column of a matrix.
+ *
+ * @param f The function to be applied to each column.
+ * @return The vector of results.
+ */
+ @Override
+ public Vector aggregateColumns(VectorFunction f) {
+ Vector r = new DenseVector(numCols());
+ for (int col = 0; col < numCols(); col++) {
+ r.set(col, f.apply(viewColumn(col)));
+ }
+ return r;
+ }
+
@Override
public double determinant() {
- int[] card = size();
- int rowSize = card[ROW];
- int columnSize = card[COL];
- if (rowSize != columnSize) {
- throw new CardinalityException(rowSize, columnSize);
+ if (rowSize() != columnSize()) {
+ throw new CardinalityException(rowSize(), columnSize());
}
- if (rowSize == 2) {
+ if (rowSize() == 2) {
return getQuick(0, 0) * getQuick(1, 1) - getQuick(0, 1) * getQuick(1, 0);
} else {
+ // TODO: this really should just be one line:
+ // TODO: new CholeskyDecomposition(this).getL().viewDiagonal().aggregate(Functions.TIMES)
int sign = 1;
double ret = 0;
- for (int i = 0; i < columnSize; i++) {
- Matrix minor = new DenseMatrix(rowSize - 1, columnSize - 1);
- for (int j = 1; j < rowSize; j++) {
+ for (int i = 0; i < columnSize(); i++) {
+ Matrix minor = new DenseMatrix(rowSize() - 1, columnSize() - 1);
+ for (int j = 1; j < rowSize(); j++) {
boolean flag = false; /* column offset flag */
- for (int k = 0; k < columnSize; k++) {
+ for (int k = 0; k < columnSize(); k++) {
if (k == i) {
flag = true;
continue;
@@ -395,9 +395,8 @@ public abstract class AbstractMatrix imp
@Override
public Matrix divide(double x) {
Matrix result = like();
- int[] c = size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < rowSize(); row++) {
+ for (int col = 0; col < columnSize(); col++) {
result.setQuick(row, col, getQuick(row, col) / x);
}
}
@@ -406,29 +405,28 @@ public abstract class AbstractMatrix imp
@Override
public double get(int row, int column) {
- int[] c = size();
- if (row < 0 || row >= c[ROW]) {
- throw new IndexException(row, c[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- if (column < 0 || column >= c[COL]) {
- throw new IndexException(column, c[COL]);
+ if (column < 0 || column >= columnSize()) {
+ throw new IndexException(column, columnSize());
}
return getQuick(row, column);
}
@Override
public Matrix minus(Matrix other) {
- int[] c = size();
- int[] o = other.size();
- if (c[ROW] != o[ROW]) {
- throw new CardinalityException(c[ROW], o[ROW]);
+ int rows = rowSize();
+ int columns = columnSize();
+ if (rows != other.rowSize()) {
+ throw new CardinalityException(rowSize(), other.rowSize());
}
- if (c[COL] != o[COL]) {
- throw new CardinalityException(c[COL], o[COL]);
+ if (columns != other.columnSize()) {
+ throw new CardinalityException(columnSize(), other.columnSize());
}
Matrix result = like();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
result.setQuick(row, col, getQuick(row, col)
- other.getQuick(row, col));
}
@@ -439,9 +437,10 @@ public abstract class AbstractMatrix imp
@Override
public Matrix plus(double x) {
Matrix result = like();
- int[] c = size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ int rows = rowSize();
+ int columns = columnSize();
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
result.setQuick(row, col, getQuick(row, col) + x);
}
}
@@ -450,17 +449,15 @@ public abstract class AbstractMatrix imp
@Override
public Matrix plus(Matrix other) {
- int[] c = size();
- int[] o = other.size();
- if (c[ROW] != o[ROW]) {
- throw new CardinalityException(c[ROW], o[ROW]);
+ if (rowSize() != other.rowSize()) {
+ throw new CardinalityException(rowSize(), other.rowSize());
}
- if (c[COL] != o[COL]) {
- throw new CardinalityException(c[COL], o[COL]);
+ if (columnSize() != other.columnSize()) {
+ throw new CardinalityException(columnSize(), other.columnSize());
}
Matrix result = like();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < rowSize(); row++) {
+ for (int col = 0; col < columnSize(); col++) {
result.setQuick(row, col, getQuick(row, col)
+ other.getQuick(row, col));
}
@@ -470,27 +467,25 @@ public abstract class AbstractMatrix imp
@Override
public void set(int row, int column, double value) {
- int[] c = size();
- if (row < 0 || row >= c[ROW]) {
- throw new IndexException(row, c[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- if (column < 0 || column >= c[COL]) {
- throw new IndexException(column, c[COL]);
+ if (column < 0 || column >= columnSize()) {
+ throw new IndexException(column, columnSize());
}
setQuick(row, column, value);
}
@Override
public void set(int row, double[] data) {
- int[] c = size();
- if (c[COL] < data.length) {
- throw new CardinalityException(c[COL], data.length);
+ if (columnSize() < data.length) {
+ throw new CardinalityException(columnSize(), data.length);
}
- if (row < 0 || row >= c[ROW]) {
- throw new IndexException(row, c[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- for (int i = 0; i < c[COL]; i++) {
+ for (int i = 0; i < columnSize(); i++) {
setQuick(row, i, data[i]);
}
}
@@ -498,9 +493,10 @@ public abstract class AbstractMatrix imp
@Override
public Matrix times(double x) {
Matrix result = like();
- int[] c = size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ int rows = rowSize();
+ int columns = columnSize();
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
result.setQuick(row, col, getQuick(row, col) * x);
}
}
@@ -509,16 +505,17 @@ public abstract class AbstractMatrix imp
@Override
public Matrix times(Matrix other) {
- int[] c = size();
- int[] o = other.size();
- if (c[COL] != o[ROW]) {
- throw new CardinalityException(c[COL], o[ROW]);
- }
- Matrix result = like(c[ROW], o[COL]);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < o[COL]; col++) {
+ int rows = rowSize();
+ int columns = other.columnSize();
+ Matrix result = like(rows, other.columnSize());
+ if (columnSize() != other.rowSize()) {
+ throw new CardinalityException(rowSize(), other.columnSize());
+ }
+
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
double sum = 0;
- for (int k = 0; k < c[COL]; k++) {
+ for (int k = 0; k < columnSize(); k++) {
sum += getQuick(row, k) * other.getQuick(k, col);
}
result.setQuick(row, col, sum);
@@ -529,25 +526,27 @@ public abstract class AbstractMatrix imp
@Override
public Vector times(Vector v) {
- int[] c = size();
- if (c[COL] != v.size()) {
- throw new CardinalityException(c[COL], v.size());
- }
- Vector w = new DenseVector(c[ROW]);
- for (int i = 0; i < c[ROW]; i++) {
- w.setQuick(i, v.dot(viewRow(i)));
+ int rows = rowSize();
+ Vector w = new DenseVector(rows);
+ if (columnSize() != v.size()) {
+ throw new CardinalityException(rowSize(), v.size());
+ }
+ for (int row = 0; row < rows; row++) {
+ w.setQuick(row, v.dot(viewRow(row)));
}
return w;
}
@Override
public Vector timesSquared(Vector v) {
- int[] c = size();
- if (c[COL] != v.size()) {
- throw new CardinalityException(c[COL], v.size());
+ int rows = rowSize();
+ int columns = columnSize();
+ if (columns != v.size()) {
+ throw new CardinalityException(columnSize(), v.size());
}
- Vector w = new DenseVector(c[COL]);
- for (int i = 0; i < c[ROW]; i++) {
+
+ Vector w = new DenseVector(columns);
+ for (int i = 0; i < rows; i++) {
Vector xi = viewRow(i);
double d = xi.dot(v);
if (d != 0.0) {
@@ -560,10 +559,11 @@ public abstract class AbstractMatrix imp
@Override
public Matrix transpose() {
- int[] card = size();
- Matrix result = like(card[COL], card[ROW]);
- for (int row = 0; row < card[ROW]; row++) {
- for (int col = 0; col < card[COL]; col++) {
+ int rows = rowSize();
+ int columns = columnSize();
+ Matrix result = like(columns, rows);
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < columns; col++) {
result.setQuick(col, row, getQuick(row, col));
}
}
@@ -578,15 +578,19 @@ public abstract class AbstractMatrix imp
@Override
public double zSum() {
double result = 0;
- int[] c = size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < rowSize(); row++) {
+ for (int col = 0; col < columnSize(); col++) {
result += getQuick(row, col);
}
}
return result;
}
+ @Override
+ public int[] getNumNondefaultElements() {
+ return new int[]{rowSize(), columnSize()};
+ }
+
protected class TransposeViewVector extends AbstractVector {
private final Matrix matrix;
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/DenseMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/DenseMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/DenseMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/DenseMatrix.java Thu Sep 1 11:29:29 2011
@@ -24,9 +24,6 @@ public class DenseMatrix extends Abstrac
private double[][] values;
- public DenseMatrix() {
- }
-
/**
* Construct a matrix from the given values
*
@@ -34,13 +31,13 @@ public class DenseMatrix extends Abstrac
* a double[][]
*/
public DenseMatrix(double[][] values) {
+ super(values.length, values[0].length);
// clone the rows
this.values = new double[values.length][];
// be careful, need to clone the columns too
for (int i = 0; i < values.length; i++) {
this.values[i] = values[i].clone();
}
- initSize();
}
/**
@@ -49,15 +46,10 @@ public class DenseMatrix extends Abstrac
* @param columns The number of columns in the result.
*/
public DenseMatrix(int rows, int columns) {
+ super(rows, columns);
this.values = new double[rows][columns];
- initSize();
}
- private void initSize() {
- cardinality[ROW] = values.length;
- cardinality[COL] = values[0].length;
- }
-
@Override
public Matrix clone() {
DenseMatrix clone = (DenseMatrix) super.clone();
@@ -87,12 +79,7 @@ public class DenseMatrix extends Abstrac
public void setQuick(int row, int column, double value) {
values[row][column] = value;
}
-
- @Override
- public int[] getNumNondefaultElements() {
- return size();
- }
-
+
@Override
public Matrix viewPart(int[] offset, int[] size) {
int rowOffset = offset[ROW];
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/DiagonalMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/DiagonalMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/DiagonalMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/DiagonalMatrix.java Thu Sep 1 11:29:29 2011
@@ -25,9 +25,8 @@ public class DiagonalMatrix extends Abst
private Vector diagonal;
public DiagonalMatrix(Vector values) {
+ super(values.size(), values.size());
this.diagonal = values;
- super.cardinality[0] = values.size();
- super.cardinality[1] = values.size();
}
public DiagonalMatrix(Matrix values) {
@@ -39,6 +38,7 @@ public class DiagonalMatrix extends Abst
}
public DiagonalMatrix(double[] values) {
+ super(values.length, values.length);
this.diagonal = new DenseVector(values);
}
@@ -95,7 +95,7 @@ public class DiagonalMatrix extends Abst
*/
@Override
public Matrix like() {
- return new SparseRowMatrix(size());
+ return new SparseRowMatrix(rowSize(), columnSize());
}
/**
@@ -107,7 +107,7 @@ public class DiagonalMatrix extends Abst
*/
@Override
public Matrix like(int rows, int columns) {
- return new SparseRowMatrix(new int[]{rows, columns});
+ return new SparseRowMatrix(rows, columns);
}
@Override
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/Matrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/Matrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/Matrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/Matrix.java Thu Sep 1 11:29:29 2011
@@ -117,13 +117,6 @@ public interface Matrix extends Cloneabl
double aggregate(DoubleDoubleFunction combiner, DoubleFunction mapper);
/**
- * Return the cardinality of the recipient (the maximum number of values)
- *
- * @return an int[2]
- */
- int[] size();
-
- /**
* @return The number of rows in the matrix.
*/
int columnSize();
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/MatrixView.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/MatrixView.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/MatrixView.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/MatrixView.java Thu Sep 1 11:29:29 2011
@@ -25,9 +25,6 @@ public class MatrixView extends Abstract
// the offset into the Matrix
private int[] offset;
- private MatrixView() {
- }
-
/**
* Construct a view of the matrix with given offset and cardinality
*
@@ -36,6 +33,7 @@ public class MatrixView extends Abstract
* @param size the int[2] size of the view
*/
public MatrixView(Matrix matrix, int[] offset, int[] size) {
+ super(size[ROW], size[COL]);
int rowOffset = offset[ROW];
if (rowOffset < 0) {
throw new IndexException(rowOffset, rowSize());
@@ -57,7 +55,6 @@ public class MatrixView extends Abstract
}
this.matrix = matrix;
this.offset = offset;
- this.cardinality = Arrays.copyOf(size, 2);
}
@Override
@@ -65,7 +62,6 @@ public class MatrixView extends Abstract
MatrixView clone = (MatrixView) super.clone();
clone.matrix = matrix.clone();
clone.offset = offset.clone();
- clone.cardinality = cardinality.clone();
return clone;
}
@@ -91,7 +87,8 @@ public class MatrixView extends Abstract
@Override
public int[] getNumNondefaultElements() {
- return cardinality;
+ return new int[]{rowSize(), columnSize()};
+
}
@Override
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/PermutedVectorView.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/PermutedVectorView.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/PermutedVectorView.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/PermutedVectorView.java Thu Sep 1 11:29:29 2011
@@ -43,7 +43,7 @@ public class PermutedVectorView extends
if (vector.isDense()) {
return new DenseMatrix(rows, columns);
} else {
- return new SparseRowMatrix(new int[] {rows, columns});
+ return new SparseRowMatrix(rows, columns);
}
}
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/PivotedMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/PivotedMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/PivotedMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/PivotedMatrix.java Thu Sep 1 11:29:29 2011
@@ -34,8 +34,7 @@ public class PivotedMatrix extends Abstr
this(base, pivot, java.util.Arrays.copyOf(pivot, pivot.length));
}
public PivotedMatrix(Matrix base, int[] rowPivot, int[] columnPivot) {
- cardinality[ROW] = base.rowSize();
- cardinality[COL] = base.columnSize();
+ super(base.rowSize(), base.columnSize());
this.base = base;
this.rowPivot = rowPivot;
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomAccessSparseVector.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomAccessSparseVector.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomAccessSparseVector.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomAccessSparseVector.java Thu Sep 1 11:29:29 2011
@@ -67,8 +67,7 @@ public class RandomAccessSparseVector ex
@Override
protected Matrix matrixLike(int rows, int columns) {
- int[] cardinality = {rows, columns};
- return new SparseRowMatrix(cardinality);
+ return new SparseRowMatrix(rows, columns);
}
@Override
Added: mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomTrinaryMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomTrinaryMatrix.java?rev=1164016&view=auto
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomTrinaryMatrix.java (added)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/RandomTrinaryMatrix.java Thu Sep 1 11:29:29 2011
@@ -0,0 +1,146 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.mahout.math;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Random matrix. Each value is taken from {-1,0,1} with roughly equal probability. Note
+ * that by default, the value is determined by a relatively simple hash of the coordinates.
+ * Such a hash is not usable where real randomness is required, but suffices nicely for
+ * random projection methods.
+ *
+ * If the simple hash method is not satisfactory, an optional high quality mode is available
+ * which uses a murmur hash of the coordinates.
+ */
+public class RandomTrinaryMatrix extends AbstractMatrix {
+ private static AtomicInteger id = new AtomicInteger();
+ private static final int PRIME1 = 104047;
+ private static final int PRIME2 = 101377;
+ private static final int PRIME3 = 64661;
+
+ private int seed;
+ private static final long SCALE = 1L << 32;
+
+ // set this to true to use a high quality hash
+ private boolean highQuality = false;
+
+ public RandomTrinaryMatrix(int seed, int rows, int columns, boolean highQuality) {
+ super(rows, columns);
+
+ this.highQuality = highQuality;
+ this.seed = seed;
+ }
+
+ public RandomTrinaryMatrix(int rows, int columns) {
+ this(id.incrementAndGet(), rows, columns, false);
+ }
+
+ @Override
+ public Matrix assignColumn(int column, Vector other) {
+ throw new UnsupportedOperationException("Can't assign to read-only matrix");
+ }
+
+ @Override
+ public Matrix assignRow(int row, Vector other) {
+ throw new UnsupportedOperationException("Can't assign to read-only matrix");
+ }
+
+ /**
+ * Return the value at the given indexes, without checking bounds
+ *
+ * @param row an int row index
+ * @param column an int column index
+ * @return the double at the index
+ */
+ @Override
+ public double getQuick(int row, int column) {
+ if (highQuality) {
+ ByteBuffer buf = ByteBuffer.allocate(8);
+ buf.putInt(row);
+ buf.putInt(column);
+ buf.flip();
+ return (MurmurHash.hash64A(buf, seed) & (SCALE - 1)) / ((double) SCALE);
+ } else {
+ // this isn't a fantastic random number generator, but it is just fine for random projections
+ return ((((row * PRIME1) + (column * PRIME2 + row * column * PRIME3)) & 8) * 0.25) - 1;
+ }
+ }
+
+
+ /**
+ * Return an empty matrix of the same underlying class as the receiver
+ *
+ * @return a Matrix
+ */
+ @Override
+ public Matrix like() {
+ return new DenseMatrix(rowSize(), columnSize());
+ }
+
+ /**
+ * Returns an empty matrix of the same underlying class as the receiver and of the specified
+ * size.
+ *
+ * @param rows the int number of rows
+ * @param columns the int number of columns
+ */
+ @Override
+ public Matrix like(int rows, int columns) {
+ return new DenseMatrix(rows, columns);
+ }
+
+ /**
+ * Set the value at the given index, without checking bounds
+ *
+ * @param row an int row index into the receiver
+ * @param column an int column index into the receiver
+ * @param value a double value to set
+ */
+ @Override
+ public void setQuick(int row, int column, double value) {
+ throw new UnsupportedOperationException("Can't assign to read-only matrix");
+ }
+
+ /**
+ * Return the number of values in the recipient
+ *
+ * @return an int[2] containing [row, column] count
+ */
+ @Override
+ public int[] getNumNondefaultElements() {
+ throw new UnsupportedOperationException("Can't assign to read-only matrix");
+ }
+
+ /**
+ * Return a new matrix containing the subset of the recipient
+ *
+ * @param offset an int[2] offset into the receiver
+ * @param size the int[2] size of the desired result
+ * @return a new Matrix that is a view of the original
+ * @throws org.apache.mahout.math.CardinalityException
+ * if the length is greater than the cardinality of the receiver
+ * @throws org.apache.mahout.math.IndexException
+ * if the offset is negative or the offset+length is outside of the receiver
+ */
+ @Override
+ public Matrix viewPart(int[] offset, int[] size) {
+ return new MatrixView(this, offset, size);
+ }
+}
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/SequentialAccessSparseVector.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/SequentialAccessSparseVector.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/SequentialAccessSparseVector.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/SequentialAccessSparseVector.java Thu Sep 1 11:29:29 2011
@@ -118,8 +118,7 @@ public class SequentialAccessSparseVecto
@Override
protected Matrix matrixLike(int rows, int columns) {
- int[] cardinality = {rows, columns};
- return new SparseRowMatrix(cardinality);
+ return new SparseRowMatrix(rows, columns);
}
@Override
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseColumnMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseColumnMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseColumnMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseColumnMatrix.java Thu Sep 1 11:29:29 2011
@@ -22,45 +22,43 @@ package org.apache.mahout.math;
* SparseVectors.
*/
public class SparseColumnMatrix extends AbstractMatrix {
- private Vector[] columns;
-
- public SparseColumnMatrix() {
- }
+ private Vector[] columnVectors;
/**
* Construct a matrix of the given cardinality with the given data columns
*
- * @param cardinality the int[2] cardinality
+ * @param rows
* @param columns a RandomAccessSparseVector[] array of columns
+ * @param columnVectors
*/
- public SparseColumnMatrix(int[] cardinality, RandomAccessSparseVector[] columns) {
- this.cardinality = cardinality.clone();
- this.columns = columns.clone();
- for (int col = 0; col < cardinality[COL]; col++) {
- this.columns[col] = columns[col].clone();
+ public SparseColumnMatrix(int rows, int columns, RandomAccessSparseVector[] columnVectors) {
+ super(rows, columns);
+ this.columnVectors = this.columnVectors.clone();
+ for (int col = 0; col < columnSize(); col++) {
+ this.columnVectors[col] = this.columnVectors[col].clone();
}
}
/**
* Construct a matrix of the given cardinality
*
- * @param cardinality the int[2] cardinality
+ * @param rows
+ * @param columns
*/
- public SparseColumnMatrix(int[] cardinality) {
- this.cardinality = cardinality.clone();
- this.columns = new RandomAccessSparseVector[cardinality[COL]];
- for (int col = 0; col < cardinality[COL]; col++) {
- this.columns[col] = new RandomAccessSparseVector(cardinality[ROW]);
+ public SparseColumnMatrix(int rows, int columns) {
+ super(rows, columns);
+ this.columnVectors = new RandomAccessSparseVector[columnSize()];
+ for (int col = 0; col < columnSize(); col++) {
+ this.columnVectors[col] = new RandomAccessSparseVector(rowSize());
}
}
@Override
public Matrix clone() {
SparseColumnMatrix clone = (SparseColumnMatrix) super.clone();
- clone.cardinality = cardinality.clone();
- clone.columns = new Vector[columns.length];
- for (int i = 0; i < columns.length; i++) {
- clone.columns[i] = columns[i].clone();
+ clone.columnVectors = new Vector[columnVectors.length];
+ for (int i = 0; i < columnVectors.length; i++) {
+ clone.columnVectors[i] = columnVectors[i].clone();
}
return clone;
}
@@ -76,36 +74,33 @@ public class SparseColumnMatrix extends
@Override
public double getQuick(int row, int column) {
- return columns[column] == null ? 0.0 : columns[column].getQuick(row);
+ return columnVectors[column] == null ? 0.0 : columnVectors[column].getQuick(row);
}
@Override
public Matrix like() {
- return new SparseColumnMatrix(cardinality);
+ return new SparseColumnMatrix(rowSize(), columnSize());
}
@Override
public Matrix like(int rows, int columns) {
- int[] c = new int[2];
- c[ROW] = rows;
- c[COL] = columns;
- return new SparseColumnMatrix(c);
+ return new SparseColumnMatrix(rows, columns);
}
@Override
public void setQuick(int row, int column, double value) {
- if (columns[column] == null) {
- columns[column] = new RandomAccessSparseVector(cardinality[ROW]);
+ if (columnVectors[column] == null) {
+ columnVectors[column] = new RandomAccessSparseVector(rowSize());
}
- columns[column].setQuick(row, value);
+ columnVectors[column].setQuick(row, value);
}
@Override
public int[] getNumNondefaultElements() {
int[] result = new int[2];
- result[COL] = columns.length;
- for (int col = 0; col < cardinality[COL]; col++) {
- result[ROW] = Math.max(result[ROW], columns[col]
+ result[COL] = columnVectors.length;
+ for (int col = 0; col < columnSize(); col++) {
+ result[ROW] = Math.max(result[ROW], columnVectors[col]
.getNumNondefaultElements());
}
return result;
@@ -114,51 +109,51 @@ public class SparseColumnMatrix extends
@Override
public Matrix viewPart(int[] offset, int[] size) {
if (offset[ROW] < 0) {
- throw new IndexException(offset[ROW], columns[COL].size());
+ throw new IndexException(offset[ROW], columnVectors[COL].size());
}
- if (offset[ROW] + size[ROW] > columns[COL].size()) {
- throw new IndexException(offset[ROW] + size[ROW], columns[COL].size());
+ if (offset[ROW] + size[ROW] > columnVectors[COL].size()) {
+ throw new IndexException(offset[ROW] + size[ROW], columnVectors[COL].size());
}
if (offset[COL] < 0) {
- throw new IndexException(offset[COL], columns.length);
+ throw new IndexException(offset[COL], columnVectors.length);
}
- if (offset[COL] + size[COL] > columns.length) {
- throw new IndexException(offset[COL] + size[COL], columns.length);
+ if (offset[COL] + size[COL] > columnVectors.length) {
+ throw new IndexException(offset[COL] + size[COL], columnVectors.length);
}
return new MatrixView(this, offset, size);
}
@Override
public Matrix assignColumn(int column, Vector other) {
- if (cardinality[ROW] != other.size()) {
- throw new CardinalityException(cardinality[ROW], other.size());
+ if (rowSize() != other.size()) {
+ throw new CardinalityException(rowSize(), other.size());
}
- if (column < 0 || column >= cardinality[COL]) {
- throw new IndexException(column, cardinality[COL]);
+ if (column < 0 || column >= columnSize()) {
+ throw new IndexException(column, columnSize());
}
- columns[column].assign(other);
+ columnVectors[column].assign(other);
return this;
}
@Override
public Matrix assignRow(int row, Vector other) {
- if (cardinality[COL] != other.size()) {
- throw new CardinalityException(cardinality[COL], other.size());
+ if (columnSize() != other.size()) {
+ throw new CardinalityException(columnSize(), other.size());
}
- if (row < 0 || row >= cardinality[ROW]) {
- throw new IndexException(row, cardinality[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- for (int col = 0; col < cardinality[COL]; col++) {
- columns[col].setQuick(row, other.getQuick(col));
+ for (int col = 0; col < columnSize(); col++) {
+ columnVectors[col].setQuick(row, other.getQuick(col));
}
return this;
}
@Override
public Vector viewColumn(int column) {
- if (column < 0 || column >= cardinality[COL]) {
- throw new IndexException(column, cardinality[COL]);
+ if (column < 0 || column >= columnSize()) {
+ throw new IndexException(column, columnSize());
}
- return columns[column];
+ return columnVectors[column];
}
}
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseMatrix.java Thu Sep 1 11:29:29 2011
@@ -27,67 +27,52 @@ import java.util.Map;
/** Doubly sparse matrix. Implemented as a Map of RandomAccessSparseVector rows */
public class SparseMatrix extends AbstractMatrix {
- private OpenIntObjectHashMap<Vector> rows;
-
- public SparseMatrix() {
- }
+ private OpenIntObjectHashMap<Vector> rowVectors;
/**
* Construct a matrix of the given cardinality with the given row map
- *
- * @param cardinality
- * the int[2] cardinality desired
+ *
* @param rows
* a Map<Integer, RandomAccessSparseVector> of rows
+ * @param columns
+ * @param rowVectors
*/
- public SparseMatrix(int[] cardinality,
- Map<Integer,RandomAccessSparseVector> rows) {
- this.cardinality = cardinality.clone();
- this.rows = new OpenIntObjectHashMap<Vector>();
- for (Map.Entry<Integer,RandomAccessSparseVector> entry : rows.entrySet()) {
- this.rows.put(entry.getKey(), entry.getValue().clone());
+ public SparseMatrix(int rows, int columns, Map<Integer, RandomAccessSparseVector> rowVectors) {
+ super(rows, columns);
+ this.rowVectors = new OpenIntObjectHashMap<Vector>();
+ for (Map.Entry<Integer, RandomAccessSparseVector> entry : rowVectors.entrySet()) {
+ this.rowVectors.put(entry.getKey(), entry.getValue().clone());
}
}
/**
- * Construct a matrix of the given cardinality
- *
- * @param cardinality
- * the int[2] cardinality desired
- */
- public SparseMatrix(int[] cardinality) {
- this.cardinality = cardinality.clone();
- this.rows = new OpenIntObjectHashMap<Vector>();
- }
-
- /**
* Construct a matrix with specified number of rows and columns.
*/
public SparseMatrix(int rows, int columns) {
- this(new int[]{rows, columns});
+ super(rows, columns);
+ this.rowVectors = new OpenIntObjectHashMap<Vector>();
}
-
+
@Override
public Matrix clone() {
SparseMatrix clone = (SparseMatrix) super.clone();
- clone.cardinality = cardinality.clone();
- clone.rows = rows.clone();
+ clone.rowVectors = rowVectors.clone();
return clone;
}
@Override
public Iterator<MatrixSlice> iterator() {
- final IntArrayList keys = new IntArrayList(rows.size());
- rows.keys(keys);
+ final IntArrayList keys = new IntArrayList(rowVectors.size());
+ rowVectors.keys(keys);
return new AbstractIterator<MatrixSlice>() {
private int slice;
@Override
protected MatrixSlice computeNext() {
- if (slice >= rows.size()) {
+ if (slice >= rowVectors.size()) {
return endOfData();
}
int i = keys.get(slice);
- Vector row = rows.get(i);
+ Vector row = rowVectors.get(i);
slice++;
return new MatrixSlice(row, i);
}
@@ -96,26 +81,26 @@ public class SparseMatrix extends Abstra
@Override
public double getQuick(int row, int column) {
- Vector r = rows.get(row);
+ Vector r = rowVectors.get(row);
return r == null ? 0.0 : r.getQuick(column);
}
@Override
public Matrix like() {
- return new SparseMatrix(cardinality);
+ return new SparseMatrix(rowSize(), columnSize());
}
@Override
public Matrix like(int rows, int columns) {
- return new SparseMatrix(new int[] {rows, columns});
+ return new SparseMatrix(rows, columns);
}
@Override
public void setQuick(int row, int column, double value) {
- Vector r = rows.get(row);
+ Vector r = rowVectors.get(row);
if (r == null) {
- r = new RandomAccessSparseVector(cardinality[COL]);
- rows.put(row, r);
+ r = new RandomAccessSparseVector(columnSize());
+ rowVectors.put(row, r);
}
r.setQuick(column, value);
}
@@ -123,8 +108,8 @@ public class SparseMatrix extends Abstra
@Override
public int[] getNumNondefaultElements() {
int[] result = new int[2];
- result[ROW] = rows.size();
- for (Vector vectorEntry : rows.values()) {
+ result[ROW] = rowVectors.size();
+ for (Vector vectorEntry : rowVectors.values()) {
result[COL] = Math.max(result[COL], vectorEntry
.getNumNondefaultElements());
}
@@ -134,35 +119,35 @@ public class SparseMatrix extends Abstra
@Override
public Matrix viewPart(int[] offset, int[] size) {
if (offset[ROW] < 0) {
- throw new IndexException(offset[ROW], cardinality[ROW]);
+ throw new IndexException(offset[ROW], rowSize());
}
- if (offset[ROW] + size[ROW] > cardinality[ROW]) {
- throw new IndexException(offset[ROW] + size[ROW], cardinality[ROW]);
+ if (offset[ROW] + size[ROW] > rowSize()) {
+ throw new IndexException(offset[ROW] + size[ROW], rowSize());
}
if (offset[COL] < 0) {
- throw new IndexException(offset[COL], cardinality[COL]);
+ throw new IndexException(offset[COL], columnSize());
}
- if (offset[COL] + size[COL] > cardinality[COL]) {
- throw new IndexException(offset[COL] + size[COL], cardinality[COL]);
+ if (offset[COL] + size[COL] > columnSize()) {
+ throw new IndexException(offset[COL] + size[COL], columnSize());
}
return new MatrixView(this, offset, size);
}
@Override
public Matrix assignColumn(int column, Vector other) {
- if (cardinality[ROW] != other.size()) {
- throw new CardinalityException(cardinality[ROW], other.size());
+ if (rowSize() != other.size()) {
+ throw new CardinalityException(rowSize(), other.size());
}
- if (column < 0 || column >= cardinality[COL]) {
- throw new IndexException(column, cardinality[COL]);
+ if (column < 0 || column >= columnSize()) {
+ throw new IndexException(column, columnSize());
}
- for (int row = 0; row < cardinality[ROW]; row++) {
+ for (int row = 0; row < rowSize(); row++) {
double val = other.getQuick(row);
if (val != 0.0) {
- Vector r = rows.get(row);
+ Vector r = rowVectors.get(row);
if (r == null) {
- r = new RandomAccessSparseVector(cardinality[COL]);
- rows.put(row, r);
+ r = new RandomAccessSparseVector(columnSize());
+ rowVectors.put(row, r);
}
r.setQuick(column, val);
}
@@ -172,24 +157,24 @@ public class SparseMatrix extends Abstra
@Override
public Matrix assignRow(int row, Vector other) {
- if (cardinality[COL] != other.size()) {
- throw new CardinalityException(cardinality[COL], other.size());
+ if (columnSize() != other.size()) {
+ throw new CardinalityException(columnSize(), other.size());
}
- if (row < 0 || row >= cardinality[ROW]) {
- throw new IndexException(row, cardinality[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- rows.put(row, other);
+ rowVectors.put(row, other);
return this;
}
@Override
public Vector viewRow(int row) {
- if (row < 0 || row >= cardinality[ROW]) {
- throw new IndexException(row, cardinality[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- Vector res = rows.get(row);
+ Vector res = rowVectors.get(row);
if (res == null) {
- res = new RandomAccessSparseVector(cardinality[COL]);
+ res = new RandomAccessSparseVector(columnSize());
}
return res;
}
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseRowMatrix.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseRowMatrix.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseRowMatrix.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/SparseRowMatrix.java Thu Sep 1 11:29:29 2011
@@ -22,94 +22,90 @@ package org.apache.mahout.math;
* either SequentialAccessSparseVectors or RandomAccessSparseVectors.
*/
public class SparseRowMatrix extends AbstractMatrix {
- private Vector[] rows;
+ private Vector[] rowVectors;
private boolean randomAccessRows;
- public SparseRowMatrix() {
- }
-
/**
- * Construct a matrix of the given cardinality with the given rows
+ * Construct a sparse matrix starting with the provided row vectors.
*
- * @param cardinality the int[2] cardinality desired
- * @param rows a Vector[] array of rows
+ * @param rows The number of rows in the result
+ * @param columns The number of columns in the result
+ * @param rowVectors a Vector[] array of rows
*/
- public SparseRowMatrix(int[] cardinality, Vector[] rows) {
- this(cardinality, rows, false, rows instanceof RandomAccessSparseVector[]);
+ public SparseRowMatrix(int rows, int columns, Vector[] rowVectors) {
+ this(rows, columns, rowVectors, false, rowVectors instanceof RandomAccessSparseVector[]);
}
- public SparseRowMatrix(int[] cardinality, boolean randomAccess) {
- this(cardinality, randomAccess
- ? new RandomAccessSparseVector[cardinality[ROW]]
- : new SequentialAccessSparseVector[cardinality[ROW]],
+ public SparseRowMatrix(int rows, int columns, boolean randomAccess) {
+ this(rows, columns, randomAccess
+ ? new RandomAccessSparseVector[rows]
+ : new SequentialAccessSparseVector[rows],
true,
randomAccess);
}
- public SparseRowMatrix(int[] cardinality, Vector[] rows, boolean shallowCopy, boolean randomAccess) {
- this.cardinality = cardinality.clone();
+ public SparseRowMatrix(int rows, int columns, Vector[] vectors, boolean shallowCopy, boolean randomAccess) {
+ super(rows, columns);
this.randomAccessRows = randomAccess;
- this.rows = rows.clone();
- for (int row = 0; row < cardinality[ROW]; row++) {
- if (rows[row] == null) {
- rows[row] = randomAccess
- ? new RandomAccessSparseVector(numCols(), 10)
- : new SequentialAccessSparseVector(numCols(), 10);
+ this.rowVectors = vectors.clone();
+ for (int row = 0; row < rows; row++) {
+ if (vectors[row] == null) {
+ // TODO: this can't be right to change the argument
+ vectors[row] = randomAccess
+ ? new RandomAccessSparseVector(numCols(), 10)
+ : new SequentialAccessSparseVector(numCols(), 10);
}
- this.rows[row] = shallowCopy ? rows[row] : rows[row].clone();
+ this.rowVectors[row] = shallowCopy ? vectors[row] : vectors[row].clone();
}
}
/**
* Construct a matrix of the given cardinality, with rows defaulting to RandomAccessSparseVector implementation
*
- * @param cardinality the int[2] cardinality desired
+ * @param rows
+ * @param columns
*/
- public SparseRowMatrix(int[] cardinality) {
- this(cardinality, true);
+ public SparseRowMatrix(int rows, int columns) {
+ this(rows, columns, true);
}
@Override
public Matrix clone() {
SparseRowMatrix clone = (SparseRowMatrix) super.clone();
- clone.cardinality = cardinality.clone();
- clone.rows = new Vector[rows.length];
- for (int i = 0; i < rows.length; i++) {
- clone.rows[i] = rows[i].clone();
+ clone.rowVectors = new Vector[rowVectors.length];
+ for (int i = 0; i < rowVectors.length; i++) {
+ clone.rowVectors[i] = rowVectors[i].clone();
}
return clone;
}
@Override
public double getQuick(int row, int column) {
- return rows[row] == null ? 0.0 : rows[row].getQuick(column);
+ return rowVectors[row] == null ? 0.0 : rowVectors[row].getQuick(column);
}
@Override
public Matrix like() {
- return new SparseRowMatrix(cardinality, randomAccessRows);
+ return new SparseRowMatrix(rowSize(), columnSize(), randomAccessRows);
}
@Override
public Matrix like(int rows, int columns) {
- int[] c = new int[2];
- c[ROW] = rows;
- c[COL] = columns;
- return new SparseRowMatrix(c, randomAccessRows);
+ return new SparseRowMatrix(rows, columns, randomAccessRows);
}
@Override
public void setQuick(int row, int column, double value) {
- rows[row].setQuick(column, value);
+ rowVectors[row].setQuick(column, value);
}
@Override
public int[] getNumNondefaultElements() {
int[] result = new int[2];
- result[ROW] = rows.length;
- for (int row = 0; row < cardinality[ROW]; row++) {
- result[COL] = Math.max(result[COL], rows[row].getNumNondefaultElements());
+ result[ROW] = rowVectors.length;
+ for (int row = 0; row < rowSize(); row++) {
+ result[COL] = Math.max(result[COL], rowVectors[row].getNumNondefaultElements());
}
return result;
}
@@ -117,43 +113,43 @@ public class SparseRowMatrix extends Abs
@Override
public Matrix viewPart(int[] offset, int[] size) {
if (offset[ROW] < 0) {
- throw new IndexException(offset[ROW], rows.length);
+ throw new IndexException(offset[ROW], rowVectors.length);
}
- if (offset[ROW] + size[ROW] > rows.length) {
- throw new IndexException(offset[ROW] + size[ROW], rows.length);
+ if (offset[ROW] + size[ROW] > rowVectors.length) {
+ throw new IndexException(offset[ROW] + size[ROW], rowVectors.length);
}
if (offset[COL] < 0) {
- throw new IndexException(offset[COL], rows[ROW].size());
+ throw new IndexException(offset[COL], rowVectors[ROW].size());
}
- if (offset[COL] + size[COL] > rows[ROW].size()) {
- throw new IndexException(offset[COL] + size[COL], rows[ROW].size());
+ if (offset[COL] + size[COL] > rowVectors[ROW].size()) {
+ throw new IndexException(offset[COL] + size[COL], rowVectors[ROW].size());
}
return new MatrixView(this, offset, size);
}
@Override
public Matrix assignColumn(int column, Vector other) {
- if (cardinality[ROW] != other.size()) {
- throw new CardinalityException(cardinality[ROW], other.size());
+ if (rowSize() != other.size()) {
+ throw new CardinalityException(rowSize(), other.size());
}
- if (column < 0 || column >= cardinality[COL]) {
- throw new IndexException(column, cardinality[COL]);
+ if (column < 0 || column >= columnSize()) {
+ throw new IndexException(column, columnSize());
}
- for (int row = 0; row < cardinality[ROW]; row++) {
- rows[row].setQuick(column, other.getQuick(row));
+ for (int row = 0; row < rowSize(); row++) {
+ rowVectors[row].setQuick(column, other.getQuick(row));
}
return this;
}
@Override
public Matrix assignRow(int row, Vector other) {
- if (cardinality[COL] != other.size()) {
- throw new CardinalityException(cardinality[COL], other.size());
+ if (columnSize() != other.size()) {
+ throw new CardinalityException(columnSize(), other.size());
}
- if (row < 0 || row >= cardinality[ROW]) {
- throw new IndexException(row, cardinality[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- rows[row].assign(other);
+ rowVectors[row].assign(other);
return this;
}
@@ -164,10 +160,10 @@ public class SparseRowMatrix extends Abs
*/
@Override
public Vector viewRow(int row) {
- if (row < 0 || row >= cardinality[ROW]) {
- throw new IndexException(row, cardinality[ROW]);
+ if (row < 0 || row >= rowSize()) {
+ throw new IndexException(row, rowSize());
}
- return rows[row];
+ return rowVectors[row];
}
}
Modified: mahout/trunk/math/src/main/java/org/apache/mahout/math/decomposer/hebbian/HebbianSolver.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/main/java/org/apache/mahout/math/decomposer/hebbian/HebbianSolver.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/main/java/org/apache/mahout/math/decomposer/hebbian/HebbianSolver.java (original)
+++ mahout/trunk/math/src/main/java/org/apache/mahout/math/decomposer/hebbian/HebbianSolver.java Thu Sep 1 11:29:29 2011
@@ -336,7 +336,7 @@ public class HebbianSolver {
TrainingState finalState = solver.solve(corpus, rank);
long time = (System.currentTimeMillis() - now) / 1000;
log.info("Solved {} eigenVectors in {} seconds. Persisted to {}",
- new Object[] {finalState.getCurrentEigens().size()[AbstractMatrix.ROW], time, outputDir});
+ new Object[] {finalState.getCurrentEigens().rowSize(), time, outputDir});
}
Modified: mahout/trunk/math/src/test/java/org/apache/mahout/math/AbstractTestVector.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/test/java/org/apache/mahout/math/AbstractTestVector.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/test/java/org/apache/mahout/math/AbstractTestVector.java (original)
+++ mahout/trunk/math/src/test/java/org/apache/mahout/math/AbstractTestVector.java Thu Sep 1 11:29:29 2011
@@ -444,10 +444,10 @@ public abstract class AbstractTestVector
@Test
public void testCrossProduct() {
Matrix result = test.cross(test);
- assertEquals("row size", test.size(), result.size()[0]);
- assertEquals("col size", test.size(), result.size()[1]);
- for (int row = 0; row < result.size()[0]; row++) {
- for (int col = 0; col < result.size()[1]; col++) {
+ assertEquals("row size", test.size(), result.rowSize());
+ assertEquals("col size", test.size(), result.columnSize());
+ for (int row = 0; row < result.rowSize(); row++) {
+ for (int col = 0; col < result.columnSize(); col++) {
assertEquals("cross[" + row + "][" + col + ']', test.getQuick(row)
* test.getQuick(col), result.getQuick(row, col), EPSILON);
}
Modified: mahout/trunk/math/src/test/java/org/apache/mahout/math/MatrixTest.java
URL: http://svn.apache.org/viewvc/mahout/trunk/math/src/test/java/org/apache/mahout/math/MatrixTest.java?rev=1164016&r1=1164015&r2=1164016&view=diff
==============================================================================
--- mahout/trunk/math/src/test/java/org/apache/mahout/math/MatrixTest.java (original)
+++ mahout/trunk/math/src/test/java/org/apache/mahout/math/MatrixTest.java Thu Sep 1 11:29:29 2011
@@ -54,18 +54,16 @@ public abstract class MatrixTest extends
@Test
public void testCardinality() {
- int[] c = test.size();
- assertEquals("row cardinality", values.length, c[ROW]);
- assertEquals("col cardinality", values[0].length, c[COL]);
+ assertEquals("row cardinality", values.length, test.rowSize());
+ assertEquals("col cardinality", values[0].length, test.columnSize());
}
@Test
public void testCopy() {
- int[] c = test.size();
Matrix copy = test.clone();
assertSame("wrong class", copy.getClass(), test.getClass());
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
test.getQuick(row, col), copy.getQuick(row, col), EPSILON);
}
@@ -85,9 +83,8 @@ public abstract class MatrixTest extends
@Test
public void testGetQuick() {
- int[] c = test.size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', values[row][col], test
.getQuick(row, col), EPSILON);
}
@@ -98,21 +95,20 @@ public abstract class MatrixTest extends
public void testLike() {
Matrix like = test.like();
assertSame("type", like.getClass(), test.getClass());
- assertEquals("rows", test.size()[ROW], like.size()[ROW]);
- assertEquals("columns", test.size()[COL], like.size()[COL]);
+ assertEquals("rows", test.rowSize(), like.rowSize());
+ assertEquals("columns", test.columnSize(), like.columnSize());
}
@Test
public void testLikeIntInt() {
Matrix like = test.like(4, 4);
assertSame("type", like.getClass(), test.getClass());
- assertEquals("rows", 4, like.size()[ROW]);
- assertEquals("columns", 4, like.size()[COL]);
+ assertEquals("rows", 4, like.rowSize());
+ assertEquals("columns", 4, like.columnSize());
}
@Test
public void testSetQuick() {
- int[] c = test.size();
for (int row = 0; row < test.rowSize(); row++) {
for (int col = 0; col < test.columnSize(); col++) {
test.setQuick(row, col, 1.23);
@@ -136,11 +132,10 @@ public abstract class MatrixTest extends
Matrix view = test.viewPart(offset, size);
assertEquals(2, view.rowSize());
assertEquals(1, view.columnSize());
- int[] c = view.size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < view.rowSize(); row++) {
+ for (int col = 0; col < view.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
- values[row + 1][col + 1], view.getQuick(row, col), EPSILON);
+ values[row + 1][col + 1], view.get(row, col), EPSILON);
}
}
}
@@ -168,10 +163,9 @@ public abstract class MatrixTest extends
@Test
public void testAssignDouble() {
- int[] c = test.size();
test.assign(4.53);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', 4.53, test.getQuick(
row, col), EPSILON);
}
@@ -180,10 +174,9 @@ public abstract class MatrixTest extends
@Test
public void testAssignDoubleArrayArray() {
- int[] c = test.size();
test.assign(new double[3][2]);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', 0.0, test.getQuick(row,
col), EPSILON);
}
@@ -192,16 +185,14 @@ public abstract class MatrixTest extends
@Test(expected = CardinalityException.class)
public void testAssignDoubleArrayArrayCardinality() {
- int[] c = test.size();
- test.assign(new double[c[ROW] + 1][c[COL]]);
+ test.assign(new double[test.rowSize() + 1][test.columnSize()]);
}
@Test
public void testAssignMatrixBinaryFunction() {
- int[] c = test.size();
test.assign(test, Functions.PLUS);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', 2 * values[row][col],
test.getQuick(row, col), EPSILON);
}
@@ -215,11 +206,10 @@ public abstract class MatrixTest extends
@Test
public void testAssignMatrix() {
- int[] c = test.size();
Matrix value = test.like();
value.assign(test);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
test.getQuick(row, col), value.getQuick(row, col), EPSILON);
}
@@ -233,10 +223,9 @@ public abstract class MatrixTest extends
@Test
public void testAssignUnaryFunction() {
- int[] c = test.size();
test.assign(Functions.mult(-1));
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', -values[row][col], test
.getQuick(row, col), EPSILON);
}
@@ -322,10 +311,9 @@ public abstract class MatrixTest extends
@Test
public void testDivide() {
- int[] c = test.size();
Matrix value = test.divide(4.53);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
values[row][col] / 4.53, value.getQuick(row, col), EPSILON);
}
@@ -334,9 +322,8 @@ public abstract class MatrixTest extends
@Test
public void testGet() {
- int[] c = test.size();
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', values[row][col], test
.get(row, col), EPSILON);
}
@@ -345,9 +332,8 @@ public abstract class MatrixTest extends
@Test(expected = IndexException.class)
public void testGetIndexUnder() {
- int[] c = test.size();
- for (int row = -1; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = -1; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
test.get(row, col);
}
}
@@ -355,9 +341,8 @@ public abstract class MatrixTest extends
@Test(expected = IndexException.class)
public void testGetIndexOver() {
- int[] c = test.size();
- for (int row = 0; row < c[ROW] + 1; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize() + 1; row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
test.get(row, col);
}
}
@@ -365,10 +350,9 @@ public abstract class MatrixTest extends
@Test
public void testMinus() {
- int[] c = test.size();
Matrix value = test.minus(test);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', 0.0, value.getQuick(
row, col), EPSILON);
}
@@ -382,10 +366,9 @@ public abstract class MatrixTest extends
@Test
public void testPlusDouble() {
- int[] c = test.size();
Matrix value = test.plus(4.53);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
values[row][col] + 4.53, value.getQuick(row, col), EPSILON);
}
@@ -394,10 +377,9 @@ public abstract class MatrixTest extends
@Test
public void testPlusMatrix() {
- int[] c = test.size();
Matrix value = test.plus(test);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']', values[row][col] * 2,
value.getQuick(row, col), EPSILON);
}
@@ -411,9 +393,8 @@ public abstract class MatrixTest extends
@Test(expected = IndexException.class)
public void testSetUnder() {
- int[] c = test.size();
- for (int row = -1; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = -1; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
test.set(row, col, 1.23);
}
}
@@ -421,9 +402,8 @@ public abstract class MatrixTest extends
@Test(expected = IndexException.class)
public void testSetOver() {
- int[] c = test.size();
- for (int row = 0; row < c[ROW] + 1; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize() + 1; row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
test.set(row, col, 1.23);
}
}
@@ -431,10 +411,9 @@ public abstract class MatrixTest extends
@Test
public void testTimesDouble() {
- int[] c = test.size();
Matrix value = test.times(4.53);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
values[row][col] * 4.53, value.getQuick(row, col), EPSILON);
}
@@ -443,12 +422,10 @@ public abstract class MatrixTest extends
@Test
public void testTimesMatrix() {
- int[] c = test.size();
Matrix transpose = test.transpose();
Matrix value = test.times(transpose);
- int[] v = value.size();
- assertEquals("rows", c[ROW], v[ROW]);
- assertEquals("cols", c[ROW], v[COL]);
+ assertEquals("rows", test.rowSize(), value.rowSize());
+ assertEquals("cols", test.rowSize(), value.columnSize());
Matrix expected = new DenseMatrix(new double[][]{{5.0, 11.0, 17.0},
{11.0, 25.0, 39.0}, {17.0, 39.0, 61.0}}).times(1.21);
@@ -495,13 +472,11 @@ public abstract class MatrixTest extends
@Test
public void testTranspose() {
- int[] c = test.size();
Matrix transpose = test.transpose();
- int[] t = transpose.size();
- assertEquals("rows", c[COL], t[ROW]);
- assertEquals("cols", c[ROW], t[COL]);
- for (int row = 0; row < c[ROW]; row++) {
- for (int col = 0; col < c[COL]; col++) {
+ assertEquals("rows", test.columnSize(), transpose.rowSize());
+ assertEquals("cols", test.rowSize(), transpose.columnSize());
+ for (int row = 0; row < test.rowSize(); row++) {
+ for (int col = 0; col < test.columnSize(); col++) {
assertEquals("value[" + row + "][" + col + ']',
test.getQuick(row, col), transpose.getQuick(col, row), EPSILON);
}