Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
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.util.Map;
 
 
A few universal implementations of convenience functions
 
 public abstract class AbstractMatrix implements Matrix {
 
   protected Map<StringIntegercolumnLabelBindings;
   protected Map<StringIntegerrowLabelBindings;
   protected int rows;
   protected int columns;
 
   protected AbstractMatrix(int rowsint columns) {
     this. = rows;
     this. = columns;
   }
 
   @Override
   public int columnSize() {
     return ;
   }
 
   @Override
   public int rowSize() {
     return ;
   }
 
   @Override
   public Iterator<MatrixSliceiterator() {
     return iterateAll();
   }
 
   @Override
   public Iterator<MatrixSliceiterateAll() {
     return new AbstractIterator<MatrixSlice>() {
       private int slice;
       @Override
       protected MatrixSlice computeNext() {
         if ( >= numSlices()) {
           return endOfData();
         }
         int i = ++;
         return new MatrixSlice(viewRow(i), i);
       }
     };
   }

  
Abstracted out for the iterator

Returns:
numRows() for row-based iterator, numColumns() for column-based.
 
   @Override
   public int numSlices() {
     return numRows();
   }
 
   @Override
   public double get(String rowLabelString columnLabel) {
     if ( == null ||  == null) {
       throw new IllegalStateException("Unbound label");
     }
     Integer row = .get(rowLabel);
     Integer col = .get(columnLabel);
     if (row == null || col == null) {
       throw new IllegalStateException("Unbound label");
     }
 
     return get(rowcol);
   }
 
   @Override
    return ;
  }
    return ;
  }
  public void set(String rowLabeldouble[] rowData) {
    if ( == null) {
      throw new IllegalStateException("Unbound label");
    }
    Integer row = .get(rowLabel);
    if (row == null) {
      throw new IllegalStateException("Unbound label");
    }
    set(rowrowData);
  }
  public void set(String rowLabelint rowdouble[] rowData) {
    if ( == null) {
       = Maps.newHashMap();
    }
    .put(rowLabelrow);
    set(rowrowData);
  }
  public void set(String rowLabelString columnLabeldouble value) {
    if ( == null ||  == null) {
      throw new IllegalStateException("Unbound label");
    }
    Integer row = .get(rowLabel);
    Integer col = .get(columnLabel);
    if (row == null || col == null) {
      throw new IllegalStateException("Unbound label");
    }
    set(rowcolvalue);
  }
  public void set(String rowLabelString columnLabelint rowint columndouble value) {
    if ( == null) {
       = Maps.newHashMap();
    }
    .put(rowLabelrow);
    if ( == null) {
       = Maps.newHashMap();
    }
    .put(columnLabelcolumn);
    set(rowcolumnvalue);
  }
  public void setColumnLabelBindings(Map<StringIntegerbindings) {
     = bindings;
  }
  public void setRowLabelBindings(Map<StringIntegerbindings) {
     = bindings;
  }
  // index into int[2] for column value
  public static final int COL = 1;
  // index into int[2] for row value
  public static final int ROW = 0;
  public int numRows() {
    return rowSize();
  }
  public int numCols() {
    return columnSize();
  }
  public String asFormatString() {
    return toString();
  }
  public Matrix assign(double value) {
    int rows = rowSize();
    int columns = columnSize();
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        setQuick(rowcolvalue);
      }
    }
    return this;
  }
  public Matrix assign(double[][] values) {
    int rows = rowSize();
    if (rows != values.length) {
      throw new CardinalityException(rowsvalues.length);
    }
    int columns = columnSize();
    for (int row = 0; row < rowsrow++) {
      if (columns == values[row].length) {
        for (int col = 0; col < columnscol++) {
          setQuick(rowcolvalues[row][col]);
        }
      } else {
        throw new CardinalityException(columnsvalues[row].length);
      }
    }
    return this;
  }
  public Matrix assign(Matrix otherDoubleDoubleFunction function) {
    int rows = rowSize();
    if (rows != other.rowSize()) {
      throw new CardinalityException(rowsother.rowSize());
    }
    int columns = columnSize();
    if (columns != other.columnSize()) {
      throw new CardinalityException(columnsother.columnSize());
    }
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        setQuick(rowcolfunction.apply(getQuick(rowcol), other.getQuick(
            rowcol)));
      }
    }
    return this;
  }
  public Matrix assign(Matrix other) {
    int rows = rowSize();
    if (rows != other.rowSize()) {
      throw new CardinalityException(rowsother.rowSize());
    }
    int columns = columnSize();
    if (columns != other.columnSize()) {
      throw new CardinalityException(columnsother.columnSize());
    }
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        setQuick(rowcolother.getQuick(rowcol));
      }
    }
    return this;
  }
  public Matrix assign(DoubleFunction function) {
    int rows = rowSize();
    int columns = columnSize();
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        setQuick(rowcolfunction.apply(getQuick(rowcol)));
      }
    }
    return this;
  }

  
Collects the results of a function applied to each row of a matrix.

Parameters:
f The function to be applied to each row.
Returns:
The vector of results.
    Vector r = new DenseVector(numRows());
    int n = numRows();
    for (int row = 0; row < nrow++) {
      r.set(rowf.apply(viewRow(row)));
    }
    return r;
  }

  
Returns a view of a row. Changes to the view will affect the original.

Parameters:
row Which row to return.
Returns:
A vector that references the desired row.
  public Vector viewRow(int row) {
    return new MatrixVectorView(thisrow, 0, 0, 1);
  }


  
Returns a view of a row. Changes to the view will affect the original.

Parameters:
column Which column to return.
Returns:
A vector that references the desired column.
  public Vector viewColumn(int column) {
    return new MatrixVectorView(this, 0, column, 1, 0);
  }

  
Provides a view of the diagonal of a matrix.
  public Vector viewDiagonal() {
    return new MatrixVectorView(this, 0, 0, 1, 1);
  }

  
Collects the results of a function applied to each element of a matrix and then aggregated.

Parameters:
combiner A function that combines the results of the mapper.
mapper A function to apply to each element.
Returns:
The result.
  public double aggregate(final DoubleDoubleFunction combinerfinal DoubleFunction mapper) {
    return aggregateRows(new VectorFunction() {
      @Override
      public double apply(Vector v) {
        return v.aggregate(combinermapper);
      }
    }).aggregate(combiner.);
  }

  
Collects the results of a function applied to each column of a matrix.

Parameters:
f The function to be applied to each column.
Returns:
The vector of results.
    Vector r = new DenseVector(numCols());
    for (int col = 0; col < numCols(); col++) {
      r.set(colf.apply(viewColumn(col)));
    }
    return r;
  }
  public double determinant() {
    int rows = rowSize();
    int columns = columnSize();
    if (rows != columns) {
      throw new CardinalityException(rowscolumns);
    }
    if (rows == 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 < columnsi++) {
        Matrix minor = new DenseMatrix(rows - 1, columns - 1);
        for (int j = 1; j < rowsj++) {
          boolean flag = false/* column offset flag */
          for (int k = 0; k < columnsk++) {
            if (k == i) {
              flag = true;
              continue;
            }
            minor.set(j - 1, flag ? k - 1 : kgetQuick(jk));
          }
        }
        ret += getQuick(0, i) * sign * minor.determinant();
        sign *= -1;
      }
      return ret;
    }
  }
  @SuppressWarnings("CloneDoesntDeclareCloneNotSupportedException")
  public Matrix clone() {
    AbstractMatrix clone;
    try {
      clone = (AbstractMatrixsuper.clone();
    } catch (CloneNotSupportedException cnse) {
      throw new IllegalStateException(cnse); // can't happen
    }
    if ( != null) {
      clone.rowLabelBindings = Maps.newHashMap();
    }
    if ( != null) {
      clone.columnLabelBindings = Maps.newHashMap();
    }
    return clone;
  }
  public Matrix divide(double x) {
    Matrix result = like();
    for (int row = 0; row < rowSize(); row++) {
      for (int col = 0; col < columnSize(); col++) {
        result.setQuick(rowcolgetQuick(rowcol) / x);
      }
    }
    return result;
  }
  public double get(int rowint column) {
    if (row < 0 || row >= rowSize()) {
      throw new IndexException(rowrowSize());
    }
    if (column < 0 || column >= columnSize()) {
      throw new IndexException(columncolumnSize());
    }
    return getQuick(rowcolumn);
  }
  public Matrix minus(Matrix other) {
    int rows = rowSize();
    if (rows != other.rowSize()) {
      throw new CardinalityException(rowsother.rowSize());
    }
    int columns = columnSize();
    if (columns != other.columnSize()) {
      throw new CardinalityException(columnsother.columnSize());
    }
    Matrix result = like();
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        result.setQuick(rowcolgetQuick(rowcol)
            - other.getQuick(rowcol));
      }
    }
    return result;
  }
  public Matrix plus(double x) {
    Matrix result = like();
    int rows = rowSize();
    int columns = columnSize();
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        result.setQuick(rowcolgetQuick(rowcol) + x);
      }
    }
    return result;
  }
  public Matrix plus(Matrix other) {
    int rows = rowSize();
    if (rows != other.rowSize()) {
      throw new CardinalityException(rowsother.rowSize());
    }
    int columns = columnSize();
    if (columns != other.columnSize()) {
      throw new CardinalityException(columnsother.columnSize());
    }
    Matrix result = like();
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        result.setQuick(rowcolgetQuick(rowcol)
            + other.getQuick(rowcol));
      }
    }
    return result;
  }
  public void set(int rowint columndouble value) {
    if (row < 0 || row >= rowSize()) {
      throw new IndexException(rowrowSize());
    }
    if (column < 0 || column >= columnSize()) {
      throw new IndexException(columncolumnSize());
    }
    setQuick(rowcolumnvalue);
  }
  public void set(int rowdouble[] data) {
    int columns = columnSize();
    if (columns < data.length) {
      throw new CardinalityException(columnsdata.length);
    }
    int rows = rowSize();
    if (row < 0 || row >= rows) {
      throw new IndexException(rowrowSize());
    }
    for (int i = 0; i < columnsi++) {
      setQuick(rowidata[i]);
    }
  }
  public Matrix times(double x) {
    Matrix result = like();
    int rows = rowSize();
    int columns = columnSize();
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        result.setQuick(rowcolgetQuick(rowcol) * x);
      }
    }
    return result;
  }
  public Matrix times(Matrix other) {
    int columns = columnSize();
    if (columns != other.rowSize()) {
      throw new CardinalityException(columnsother.rowSize());
    }
    int rows = rowSize();
    int otherColumns = other.columnSize();
    Matrix result = like(rowsotherColumns);
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < otherColumnscol++) {
        double sum = 0.0;
        for (int k = 0; k < columnsk++) {
          sum += getQuick(rowk) * other.getQuick(kcol);
        }
        result.setQuick(rowcolsum);
      }
    }
    return result;
  }
  public Vector times(Vector v) {
    int columns = columnSize();
    if (columns != v.size()) {
      throw new CardinalityException(columnsv.size());
    }
    int rows = rowSize();
    Vector w = new DenseVector(rows);
    for (int row = 0; row < rowsrow++) {
      w.setQuick(rowv.dot(viewRow(row)));
    }
    return w;
  }
  public Vector timesSquared(Vector v) {
    int columns = columnSize();
    if (columns != v.size()) {
      throw new CardinalityException(columnsv.size());
    }
    int rows = rowSize();
    Vector w = new DenseVector(columns);
    for (int i = 0; i < rowsi++) {
      Vector xi = viewRow(i);
      double d = xi.dot(v);
      if (d != 0.0) {
        w.assign(xinew PlusMult(d));
      }
    }
    return w;
  }
  public Matrix transpose() {
    int rows = rowSize();
    int columns = columnSize();
    Matrix result = like(columnsrows);
    for (int row = 0; row < rowsrow++) {
      for (int col = 0; col < columnscol++) {
        result.setQuick(colrowgetQuick(rowcol));
      }
    }
    return result;
  }
  public Matrix viewPart(int rowOffsetint rowsRequestedint columnOffsetint columnsRequested) {
    return viewPart(new int[]{rowOffsetcolumnOffset}, new int[]{rowsRequestedcolumnsRequested});
  }
  public double zSum() {
    double result = 0;
    for (int row = 0; row < rowSize(); row++) {
      for (int col = 0; col < columnSize(); col++) {
        result += getQuick(rowcol);
      }
    }
    return result;
  }
  public int[] getNumNondefaultElements() {
    return new int[]{rowSize(), columnSize()};
  }
  protected static class TransposeViewVector extends AbstractVector {
    private final Matrix matrix;
    private final int transposeOffset;
    private final int numCols;
    private final boolean rowToColumn;
    protected TransposeViewVector(Matrix mint offset) {
      this(moffsettrue);
    }
    protected TransposeViewVector(Matrix mint offsetboolean rowToColumn) {
      super(rowToColumn ? m.numRows() : m.numCols());
       = m;
      this. = offset;
      this. = rowToColumn;
       = rowToColumn ? m.numCols() : m.numRows();
    }
    @SuppressWarnings("CloneDoesntCallSuperClone")
    @Override
    public Vector clone() {
      Vector v = new DenseVector(size());
      v.assign(this.);
      return v;
    }
    @Override
    public boolean isDense() {
      return true;
    }
    @Override
    public boolean isSequentialAccess() {
      return true;
    }
    @Override
    protected Matrix matrixLike(int rowsint columns) {
      return .like(rowscolumns);
    }
    @Override
    public Iterator<Elementiterator() {
      return new AbstractIterator<Element>() {
        private int i;
        @Override
        protected Element computeNext() {
          if ( >= size()) {
            return endOfData();
          }
          return getElement(++);
        }
      };
    }

    
Currently delegates to iterator(). TODO: This could be optimized to at least skip empty rows if there are many of them.

Returns:
an iterator (currently dense).
    @Override
    public Iterator<ElementiterateNonZero() {
      return iterator();
    }
    @Override
    public Element getElement(final int i) {
      return new Element() {
        @Override
        public double get() {
          return getQuick(i);
        }
        @Override
        public int index() {
          return i;
        }
        @Override
        public void set(double value) {
          setQuick(ivalue);
        }
      };
    }

    
Used internally by assign() to update multiple indices and values at once. Only really useful for sparse vectors (especially SequentialAccessSparseVector).

If someone ever adds a new type of sparse vectors, this method must merge (index, value) pairs into the vector.

Parameters:
updates a mapping of indices to values to merge in the vector.
    @Override
    public void mergeUpdates(OrderedIntDoubleMapping updates) {
      throw new UnsupportedOperationException("Cannot mutate TransposeViewVector");
    }
    @Override
    public double getQuick(int index) {
      Vector v =  ? .viewColumn(index) : .viewRow(index);
      return v == null ? 0.0 : v.getQuick();
    }
    @Override
    public void setQuick(int indexdouble value) {
      Vector v =  ? .viewColumn(index) : .viewRow(index);
      if (v == null) {
        v = newVector();
        if () {
          .assignColumn(indexv);
        } else {
          .assignRow(indexv);
        }
      }
      v.setQuick(value);
    }
    protected Vector newVector(int cardinality) {
      return new DenseVector(cardinality);
    }
    @Override
    public Vector like() {
      return new DenseVector(size());
    }
    public Vector like(int cardinality) {
      return new DenseVector(cardinality);
    }

    
TODO: currently I don't know of an efficient way to getVector this value correctly.

Returns:
the number of nonzero entries
    @Override
    public int getNumNondefaultElements() {
      return size();
    }
    @Override
    public double getLookupCost() {
      return ( ? .viewColumn(0) : .viewRow(0)).getLookupCost();
    }
    @Override
    public double getIteratorAdvanceCost() {
      return ( ? .viewColumn(0) : .viewRow(0)).getIteratorAdvanceCost();
    }
    @Override
    public boolean isAddConstantTime() {
      return ( ? .viewColumn(0) : .viewRow(0)).isAddConstantTime();
    }
  }
  public String toString() {
    StringBuilder s = new StringBuilder("{\n");
    Iterator<MatrixSliceit = iterator();
    while (it.hasNext()) {
      MatrixSlice next = it.next();
      s.append("  ").append(next.index()).append("  =>\t").append(next.vector()).append('\n');
    }
    s.append("}");
    return s.toString();
  }
New to GrepCode? Check out our FAQ X