You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2009/04/19 18:39:41 UTC
svn commit: r766485 [2/4] - in /commons/proper/math/trunk: ./
src/java/org/apache/commons/math/ src/java/org/apache/commons/math/linear/
src/java/org/apache/commons/math/linear/decomposition/ src/site/xdoc/
src/site/xdoc/userguide/ src/test/org/apache/...
Added: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrix.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrix.java?rev=766485&view=auto
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrix.java (added)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrix.java Sun Apr 19 16:39:40 2009
@@ -0,0 +1,819 @@
+/*
+ * 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.commons.math.linear;
+
+import java.io.Serializable;
+
+import org.apache.commons.math.Field;
+import org.apache.commons.math.FieldElement;
+import org.apache.commons.math.linear.decomposition.NonSquareMatrixException;
+
+/**
+ * Interface defining field-valued matrix with basic algebraic operations.
+ * <p>
+ * Matrix element indexing is 0-based -- e.g., <code>getEntry(0, 0)</code>
+ * returns the element in the first row, first column of the matrix.</p>
+ *
+ * @param <T> the type of the field elements
+ * @version $Revision$ $Date$
+ */
+public interface FieldMatrix<T extends FieldElement<T>> extends Serializable {
+
+ /**
+ * Get the type of field elements of the matrix.
+ * @return type of field elements of the matrix
+ */
+ Field<T> getField();
+
+ /**
+ * Create a new FieldMatrix<T> of the same type as the instance with the supplied
+ * row and column dimensions.
+ *
+ * @param rowDimension the number of rows in the new matrix
+ * @param columnDimension the number of columns in the new matrix
+ * @return a new matrix of the same type as the instance
+ * @throws IllegalArgumentException if row or column dimension is not positive
+ * @since 2.0
+ */
+ FieldMatrix<T> createMatrix(final int rowDimension, final int columnDimension);
+
+ /**
+ * Returns a (deep) copy of this.
+ *
+ * @return matrix copy
+ */
+ FieldMatrix<T> copy();
+
+ /**
+ * Compute the sum of this and m.
+ *
+ * @param m matrix to be added
+ * @return this + m
+ * @throws IllegalArgumentException if m is not the same size as this
+ */
+ FieldMatrix<T> add(FieldMatrix<T> m) throws IllegalArgumentException;
+
+ /**
+ * Compute this minus m.
+ *
+ * @param m matrix to be subtracted
+ * @return this + m
+ * @throws IllegalArgumentException if m is not the same size as this
+ */
+ FieldMatrix<T> subtract(FieldMatrix<T> m) throws IllegalArgumentException;
+
+ /**
+ * Returns the result of adding d to each entry of this.
+ *
+ * @param d value to be added to each entry
+ * @return d + this
+ */
+ FieldMatrix<T> scalarAdd(T d);
+
+ /**
+ * Returns the result multiplying each entry of this by d.
+ *
+ * @param d value to multiply all entries by
+ * @return d * this
+ */
+ FieldMatrix<T> scalarMultiply(T d);
+
+ /**
+ * Returns the result of postmultiplying this by m.
+ *
+ * @param m matrix to postmultiply by
+ * @return this * m
+ * @throws IllegalArgumentException
+ * if columnDimension(this) != rowDimension(m)
+ */
+ FieldMatrix<T> multiply(FieldMatrix<T> m) throws IllegalArgumentException;
+
+ /**
+ * Returns the result premultiplying this by <code>m</code>.
+ * @param m matrix to premultiply by
+ * @return m * this
+ * @throws IllegalArgumentException
+ * if rowDimension(this) != columnDimension(m)
+ */
+ public FieldMatrix<T> preMultiply(FieldMatrix<T> m) throws IllegalArgumentException;
+
+ /**
+ * Returns matrix entries as a two-dimensional array.
+ *
+ * @return 2-dimensional array of entries
+ */
+ T[][] getData();
+
+ /**
+ * Gets a submatrix. Rows and columns are indicated
+ * counting from 0 to n-1.
+ *
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index (inclusive)
+ * @return The subMatrix containing the data of the
+ * specified rows and columns
+ * @exception MatrixIndexException if the indices are not valid
+ */
+ FieldMatrix<T> getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException;
+
+ /**
+ * Gets a submatrix. Rows and columns are indicated
+ * counting from 0 to n-1.
+ *
+ * @param selectedRows Array of row indices.
+ * @param selectedColumns Array of column indices.
+ * @return The subMatrix containing the data in the
+ * specified rows and columns
+ * @exception MatrixIndexException if row or column selections are not valid
+ */
+ FieldMatrix<T> getSubMatrix(int[] selectedRows, int[] selectedColumns)
+ throws MatrixIndexException;
+
+ /**
+ * Copy a submatrix. Rows and columns are indicated
+ * counting from 0 to n-1.
+ *
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index (inclusive)
+ * @param destination The arrays where the submatrix data should be copied
+ * (if larger than rows/columns counts, only the upper-left part will be used)
+ * @exception MatrixIndexException if the indices are not valid
+ * @exception IllegalArgumentException if the destination array is too small
+ */
+ void copySubMatrix(int startRow, int endRow, int startColumn, int endColumn,
+ T[][] destination)
+ throws MatrixIndexException, IllegalArgumentException;
+
+ /**
+ * Copy a submatrix. Rows and columns are indicated
+ * counting from 0 to n-1.
+ *
+ * @param selectedRows Array of row indices.
+ * @param selectedColumns Array of column indices.
+ * @param destination The arrays where the submatrix data should be copied
+ * (if larger than rows/columns counts, only the upper-left part will be used)
+ * @exception MatrixIndexException if the indices are not valid
+ * @exception IllegalArgumentException if the destination array is too small
+ */
+ void copySubMatrix(int[] selectedRows, int[] selectedColumns, T[][] destination)
+ throws MatrixIndexException, IllegalArgumentException;
+
+ /**
+ * Replace the submatrix starting at <code>row, column</code> using data in
+ * the input <code>subMatrix</code> array. Indexes are 0-based.
+ * <p>
+ * Example:<br>
+ * Starting with <pre>
+ * 1 2 3 4
+ * 5 6 7 8
+ * 9 0 1 2
+ * </pre>
+ * and <code>subMatrix = {{3, 4} {5,6}}</code>, invoking
+ * <code>setSubMatrix(subMatrix,1,1))</code> will result in <pre>
+ * 1 2 3 4
+ * 5 3 4 8
+ * 9 5 6 2
+ * </pre></p>
+ *
+ * @param subMatrix array containing the submatrix replacement data
+ * @param row row coordinate of the top, left element to be replaced
+ * @param column column coordinate of the top, left element to be replaced
+ * @throws MatrixIndexException if subMatrix does not fit into this
+ * matrix from element in (row, column)
+ * @throws IllegalArgumentException if <code>subMatrix</code> is not rectangular
+ * (not all rows have the same length) or empty
+ * @throws NullPointerException if <code>subMatrix</code> is null
+ * @since 2.0
+ */
+ void setSubMatrix(T[][] subMatrix, int row, int column)
+ throws MatrixIndexException;
+
+ /**
+ * Returns the entries in row number <code>row</code>
+ * as a row matrix. Row indices start at 0.
+ *
+ * @param row the row to be fetched
+ * @return row matrix
+ * @throws MatrixIndexException if the specified row index is invalid
+ */
+ FieldMatrix<T> getRowMatrix(int row) throws MatrixIndexException;
+
+ /**
+ * Sets the entries in row number <code>row</code>
+ * as a row matrix. Row indices start at 0.
+ *
+ * @param row the row to be set
+ * @param matrix row matrix (must have one row and the same number of columns
+ * as the instance)
+ * @throws MatrixIndexException if the specified row index is invalid
+ * @throws InvalidMatrixException if the matrix dimensions do not match one
+ * instance row
+ */
+ void setRowMatrix(int row, FieldMatrix<T> matrix)
+ throws MatrixIndexException, InvalidMatrixException;
+
+ /**
+ * Returns the entries in column number <code>column</code>
+ * as a column matrix. Column indices start at 0.
+ *
+ * @param column the column to be fetched
+ * @return column matrix
+ * @throws MatrixIndexException if the specified column index is invalid
+ */
+ FieldMatrix<T> getColumnMatrix(int column) throws MatrixIndexException;
+
+ /**
+ * Sets the entries in column number <code>column</code>
+ * as a column matrix. Column indices start at 0.
+ *
+ * @param column the column to be set
+ * @param matrix column matrix (must have one column and the same number of rows
+ * as the instance)
+ * @throws MatrixIndexException if the specified column index is invalid
+ * @throws InvalidMatrixException if the matrix dimensions do not match one
+ * instance column
+ */
+ void setColumnMatrix(int column, FieldMatrix<T> matrix)
+ throws MatrixIndexException, InvalidMatrixException;
+
+ /**
+ * Returns the entries in row number <code>row</code>
+ * as a vector. Row indices start at 0.
+ *
+ * @param row the row to be fetched
+ * @return row vector
+ * @throws MatrixIndexException if the specified row index is invalid
+ */
+ FieldVector<T> getRowVector(int row) throws MatrixIndexException;
+
+ /**
+ * Sets the entries in row number <code>row</code>
+ * as a vector. Row indices start at 0.
+ *
+ * @param row the row to be set
+ * @param vector row vector (must have the same number of columns
+ * as the instance)
+ * @throws MatrixIndexException if the specified row index is invalid
+ * @throws InvalidMatrixException if the vector dimension does not match one
+ * instance row
+ */
+ void setRowVector(int row, FieldVector<T> vector)
+ throws MatrixIndexException, InvalidMatrixException;
+
+ /**
+ * Returns the entries in column number <code>column</code>
+ * as a vector. Column indices start at 0.
+ *
+ * @param column the column to be fetched
+ * @return column vector
+ * @throws MatrixIndexException if the specified column index is invalid
+ */
+ FieldVector<T> getColumnVector(int column) throws MatrixIndexException;
+
+ /**
+ * Sets the entries in column number <code>column</code>
+ * as a vector. Column indices start at 0.
+ *
+ * @param column the column to be set
+ * @param vector column vector (must have the same number of rows as the instance)
+ * @throws MatrixIndexException if the specified column index is invalid
+ * @throws InvalidMatrixException if the vector dimension does not match one
+ * instance column
+ */
+ void setColumnVector(int column, FieldVector<T> vector)
+ throws MatrixIndexException, InvalidMatrixException;
+
+ /**
+ * Returns the entries in row number <code>row</code> as an array.
+ * <p>
+ * Row indices start at 0. A <code>MatrixIndexException</code> is thrown
+ * unless <code>0 <= row < rowDimension.</code></p>
+ *
+ * @param row the row to be fetched
+ * @return array of entries in the row
+ * @throws MatrixIndexException if the specified row index is not valid
+ */
+ T[] getRow(int row) throws MatrixIndexException;
+
+ /**
+ * Sets the entries in row number <code>row</code>
+ * as a row matrix. Row indices start at 0.
+ *
+ * @param row the row to be set
+ * @param array row matrix (must have the same number of columns as the instance)
+ * @throws MatrixIndexException if the specified row index is invalid
+ * @throws InvalidMatrixException if the array size does not match one
+ * instance row
+ */
+ void setRow(int row, T[] array)
+ throws MatrixIndexException, InvalidMatrixException;
+
+ /**
+ * Returns the entries in column number <code>col</code> as an array.
+ * <p>
+ * Column indices start at 0. A <code>MatrixIndexException</code> is thrown
+ * unless <code>0 <= column < columnDimension.</code></p>
+ *
+ * @param column the column to be fetched
+ * @return array of entries in the column
+ * @throws MatrixIndexException if the specified column index is not valid
+ */
+ T[] getColumn(int column) throws MatrixIndexException;
+
+ /**
+ * Sets the entries in column number <code>column</code>
+ * as a column matrix. Column indices start at 0.
+ *
+ * @param column the column to be set
+ * @param array column array (must have the same number of rows as the instance)
+ * @throws MatrixIndexException if the specified column index is invalid
+ * @throws InvalidMatrixException if the array size does not match one
+ * instance column
+ */
+ void setColumn(int column, T[] array)
+ throws MatrixIndexException, InvalidMatrixException;
+
+ /**
+ * Returns the entry in the specified row and column.
+ * <p>
+ * Row and column indices start at 0 and must satisfy
+ * <ul>
+ * <li><code>0 <= row < rowDimension</code></li>
+ * <li><code> 0 <= column < columnDimension</code></li>
+ * </ul>
+ * otherwise a <code>MatrixIndexException</code> is thrown.</p>
+ *
+ * @param row row location of entry to be fetched
+ * @param column column location of entry to be fetched
+ * @return matrix entry in row,column
+ * @throws MatrixIndexException if the row or column index is not valid
+ */
+ T getEntry(int row, int column) throws MatrixIndexException;
+
+ /**
+ * Set the entry in the specified row and column.
+ * <p>
+ * Row and column indices start at 0 and must satisfy
+ * <ul>
+ * <li><code>0 <= row < rowDimension</code></li>
+ * <li><code> 0 <= column < columnDimension</code></li>
+ * </ul>
+ * otherwise a <code>MatrixIndexException</code> is thrown.</p>
+ *
+ * @param row row location of entry to be set
+ * @param column column location of entry to be set
+ * @param value matrix entry to be set in row,column
+ * @throws MatrixIndexException if the row or column index is not valid
+ * @since 2.0
+ */
+ void setEntry(int row, int column, T value) throws MatrixIndexException;
+
+ /**
+ * Change an entry in the specified row and column.
+ * <p>
+ * Row and column indices start at 0 and must satisfy
+ * <ul>
+ * <li><code>0 <= row < rowDimension</code></li>
+ * <li><code> 0 <= column < columnDimension</code></li>
+ * </ul>
+ * otherwise a <code>MatrixIndexException</code> is thrown.</p>
+ *
+ * @param row row location of entry to be set
+ * @param column column location of entry to be set
+ * @param increment value to add to the current matrix entry in row,column
+ * @throws MatrixIndexException if the row or column index is not valid
+ * @since 2.0
+ */
+ void addToEntry(int row, int column, T increment) throws MatrixIndexException;
+
+ /**
+ * Change an entry in the specified row and column.
+ * <p>
+ * Row and column indices start at 0 and must satisfy
+ * <ul>
+ * <li><code>0 <= row < rowDimension</code></li>
+ * <li><code> 0 <= column < columnDimension</code></li>
+ * </ul>
+ * otherwise a <code>MatrixIndexException</code> is thrown.</p>
+ *
+ * @param row row location of entry to be set
+ * @param column column location of entry to be set
+ * @param factor multiplication factor for the current matrix entry in row,column
+ * @throws MatrixIndexException if the row or column index is not valid
+ * @since 2.0
+ */
+ void multiplyEntry(int row, int column, T factor) throws MatrixIndexException;
+
+ /**
+ * Returns the transpose of this matrix.
+ *
+ * @return transpose matrix
+ */
+ FieldMatrix<T> transpose();
+
+ /**
+ * Is this a square matrix?
+ * @return true if the matrix is square (rowDimension = columnDimension)
+ */
+ boolean isSquare();
+
+ /**
+ * Returns the number of rows in the matrix.
+ *
+ * @return rowDimension
+ */
+ int getRowDimension();
+
+ /**
+ * Returns the number of columns in the matrix.
+ *
+ * @return columnDimension
+ */
+ int getColumnDimension();
+
+ /**
+ * Returns the <a href="http://mathworld.wolfram.com/MatrixTrace.html">
+ * trace</a> of the matrix (the sum of the elements on the main diagonal).
+ *
+ * @return trace
+ * @throws NonSquareMatrixException if the matrix is not square
+ */
+ T getTrace() throws NonSquareMatrixException;
+
+ /**
+ * Returns the result of multiplying this by the vector <code>v</code>.
+ *
+ * @param v the vector to operate on
+ * @return this*v
+ * @throws IllegalArgumentException if columnDimension != v.size()
+ */
+ T[] operate(T[] v) throws IllegalArgumentException;
+
+ /**
+ * Returns the result of multiplying this by the vector <code>v</code>.
+ *
+ * @param v the vector to operate on
+ * @return this*v
+ * @throws IllegalArgumentException if columnDimension != v.size()
+ */
+ FieldVector<T> operate(FieldVector<T> v) throws IllegalArgumentException;
+
+ /**
+ * Returns the (row) vector result of premultiplying this by the vector <code>v</code>.
+ *
+ * @param v the row vector to premultiply by
+ * @return v*this
+ * @throws IllegalArgumentException if rowDimension != v.size()
+ */
+ T[] preMultiply(T[] v) throws IllegalArgumentException;
+
+ /**
+ * Returns the (row) vector result of premultiplying this by the vector <code>v</code>.
+ *
+ * @param v the row vector to premultiply by
+ * @return v*this
+ * @throws IllegalArgumentException if rowDimension != v.size()
+ */
+ FieldVector<T> preMultiply(FieldVector<T> v) throws IllegalArgumentException;
+
+ /**
+ * Visit (and possibly change) all matrix entries in row order.
+ * <p>Row order starts at upper left and iterating through all elements
+ * of a row from left to right before going to the leftmost element
+ * of the next row.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixChangingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInRowOrder(FieldMatrixChangingVisitor<T> visitor)
+ throws MatrixVisitorException;
+
+ /**
+ * Visit (but don't change) all matrix entries in row order.
+ * <p>Row order starts at upper left and iterating through all elements
+ * of a row from left to right before going to the leftmost element
+ * of the next row.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixPreservingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor)
+ throws MatrixVisitorException;
+
+ /**
+ * Visit (and possibly change) some matrix entries in row order.
+ * <p>Row order starts at upper left and iterating through all elements
+ * of a row from left to right before going to the leftmost element
+ * of the next row.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @exception MatrixIndexException if the indices are not valid
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixChangingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInRowOrder(FieldMatrixChangingVisitor<T> visitor,
+ int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException, MatrixVisitorException;
+
+ /**
+ * Visit (but don't change) some matrix entries in row order.
+ * <p>Row order starts at upper left and iterating through all elements
+ * of a row from left to right before going to the leftmost element
+ * of the next row.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @exception MatrixIndexException if the indices are not valid
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixPreservingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor,
+ int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException, MatrixVisitorException;
+
+ /**
+ * Visit (and possibly change) all matrix entries in column order.
+ * <p>Column order starts at upper left and iterating through all elements
+ * of a column from top to bottom before going to the topmost element
+ * of the next column.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixChangingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor)
+ throws MatrixVisitorException;
+
+ /**
+ * Visit (but don't change) all matrix entries in column order.
+ * <p>Column order starts at upper left and iterating through all elements
+ * of a column from top to bottom before going to the topmost element
+ * of the next column.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixPreservingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor)
+ throws MatrixVisitorException;
+
+ /**
+ * Visit (and possibly change) some matrix entries in column order.
+ * <p>Column order starts at upper left and iterating through all elements
+ * of a column from top to bottom before going to the topmost element
+ * of the next column.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @exception MatrixIndexException if the indices are not valid
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixChangingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor,
+ int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException, MatrixVisitorException;
+
+ /**
+ * Visit (but don't change) some matrix entries in column order.
+ * <p>Column order starts at upper left and iterating through all elements
+ * of a column from top to bottom before going to the topmost element
+ * of the next column.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @exception MatrixIndexException if the indices are not valid
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixPreservingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor,
+ int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException, MatrixVisitorException;
+
+ /**
+ * Visit (and possibly change) all matrix entries using the fastest possible order.
+ * <p>The fastest walking order depends on the exact matrix class. It may be
+ * different from traditional row or column orders.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixChangingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor)
+ throws MatrixVisitorException;
+
+ /**
+ * Visit (but don't change) all matrix entries using the fastest possible order.
+ * <p>The fastest walking order depends on the exact matrix class. It may be
+ * different from traditional row or column orders.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixPreservingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor)
+ throws MatrixVisitorException;
+
+ /**
+ * Visit (and possibly change) some matrix entries using the fastest possible order.
+ * <p>The fastest walking order depends on the exact matrix class. It may be
+ * different from traditional row or column orders.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index (inclusive)
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @exception MatrixIndexException if the indices are not valid
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixChangingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor,
+ int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException, MatrixVisitorException;
+
+ /**
+ * Visit (but don't change) some matrix entries using the fastest possible order.
+ * <p>The fastest walking order depends on the exact matrix class. It may be
+ * different from traditional row or column orders.</p>
+ * @param visitor visitor used to process all matrix entries
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index (inclusive)
+ * @exception MatrixVisitorException if the visitor cannot process an entry
+ * @exception MatrixIndexException if the indices are not valid
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInRowOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInRowOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInColumnOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @see #walkInColumnOrder(FieldMatrixPreservingVisitor, int, int, int, int)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixPreservingVisitor)
+ * @see #walkInOptimizedOrder(FieldMatrixChangingVisitor, int, int, int, int)
+ * @return the value returned by {@link FieldMatrixPreservingVisitor#end()} at the end
+ * of the walk
+ */
+ T walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor,
+ int startRow, int endRow, int startColumn, int endColumn)
+ throws MatrixIndexException, MatrixVisitorException;
+
+}
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrix.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrix.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixChangingVisitor.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixChangingVisitor.java?rev=766485&view=auto
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixChangingVisitor.java (added)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixChangingVisitor.java Sun Apr 19 16:39:40 2009
@@ -0,0 +1,64 @@
+/*
+ * 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.commons.math.linear;
+
+import java.io.Serializable;
+
+import org.apache.commons.math.FieldElement;
+
+/**
+ * Interface defining a visitor for matrix entries.
+ *
+ * @param <T> the type of the field elements
+ * @version $Revision$ $Date$
+ * @since 2.0
+ */
+public interface FieldMatrixChangingVisitor<T extends FieldElement<?>> extends Serializable {
+
+ /**
+ * Start visiting a matrix.
+ * <p>This method is called once before any entry of the matrix is visited.</p>
+ * @param rows number of rows of the matrix
+ * @param columns number of columns of the matrix
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index (inclusive)
+ */
+ void start(int rows, int columns,
+ int startRow, int endRow, int startColumn, int endColumn);
+
+ /**
+ * Visit one matrix entry.
+ * @param row row index of the entry
+ * @param column column index of the entry
+ * @param value current value of the entry
+ * @return the new value to be set for the entry
+ * @throws MatrixVisitorException if something wrong occurs
+ */
+ T visit(int row, int column, T value)
+ throws MatrixVisitorException;
+
+ /**
+ * End visiting a matrix.
+ * <p>This method is called once after all entries of the matrix have been visited.</p>
+ * @return the value that the <code>walkInXxxOrder</code> must return
+ */
+ T end();
+
+}
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixChangingVisitor.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixChangingVisitor.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixImpl.java?rev=766485&view=auto
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixImpl.java (added)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixImpl.java Sun Apr 19 16:39:40 2009
@@ -0,0 +1,655 @@
+/*
+ * 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.commons.math.linear;
+
+import java.util.Arrays;
+
+import org.apache.commons.math.Field;
+import org.apache.commons.math.FieldElement;
+import org.apache.commons.math.MathRuntimeException;
+
+/**
+ * Implementation of FieldMatrix<T> using a {@link FieldElement}[][] array to store entries.
+ * <p>
+ * As specified in the {@link FieldMatrix} interface, matrix element indexing
+ * is 0-based -- e.g., <code>getEntry(0, 0)</code>
+ * returns the element in the first row, first column of the matrix.</li></ul>
+ * </p>
+ *
+ * @param <T> the type of the field elements
+ * @version $Revision$ $Date$
+ */
+public class FieldMatrixImpl<T extends FieldElement<T>> extends AbstractFieldMatrix<T> {
+
+ /** Serializable version identifier */
+ private static final long serialVersionUID = 7260756672015356458L;
+
+ /** Entries of the matrix */
+ protected T[][] data;
+
+ /**
+ * Get the elements type from an array.
+ * @param d data array
+ * @return field to which array elements belong
+ * @exception IllegalArgumentException if array is empty
+ */
+ private static Field<? extends FieldElement<?>> extractField(final FieldElement<? extends FieldElement<?>>[][] d)
+ throws IllegalArgumentException {
+ if (d.length == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one row");
+ }
+ if (d[0].length == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one column");
+ }
+ return d[0][0].getField();
+ }
+
+ /**
+ * Get the elements type from an array.
+ * @param d data array
+ * @return field to which array elements belong
+ * @exception IllegalArgumentException if array is empty
+ */
+ private static Field<? extends FieldElement<?>> extractField(final FieldElement<? extends FieldElement<?>>[] d)
+ throws IllegalArgumentException {
+ if (d.length == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one row");
+ }
+ return d[0].getField();
+ }
+
+ /**
+ * Creates a matrix with no data
+ * @param field field to which the elements belong
+ */
+ public FieldMatrixImpl(final Field<T> field) {
+ super(field);
+ }
+
+ /**
+ * Create a new FieldMatrix<T> with the supplied row and column dimensions.
+ *
+ * @param field field to which the elements belong
+ * @param rowDimension the number of rows in the new matrix
+ * @param columnDimension the number of columns in the new matrix
+ * @throws IllegalArgumentException if row or column dimension is not
+ * positive
+ */
+ public FieldMatrixImpl(final Field<T> field,
+ final int rowDimension, final int columnDimension)
+ throws IllegalArgumentException {
+ super(field, rowDimension, columnDimension);
+ data = buildArray(rowDimension, columnDimension);
+ final T zero = field.getZero();
+ for (int i = 0; i < rowDimension; ++i) {
+ Arrays.fill(data[i], zero);
+ }
+ }
+
+ /**
+ * Create a new FieldMatrix<T> using the input array as the underlying
+ * data array.
+ * <p>The input array is copied, not referenced. This constructor has
+ * the same effect as calling {@link #FieldMatrixImpl(T[][], boolean)}
+ * with the second argument set to <code>true</code>.</p>
+ *
+ * @param d data for new matrix
+ * @throws IllegalArgumentException if <code>d</code> is not rectangular
+ * (not all rows have the same length) or empty
+ * @throws NullPointerException if <code>d</code> is null
+ * @see #FieldMatrixImpl(T[][], boolean)
+ */
+ @SuppressWarnings("unchecked")
+ public FieldMatrixImpl(final T[][] d)
+ throws IllegalArgumentException, NullPointerException {
+ super((Field<T>) extractField(d));
+ copyIn(d);
+ }
+
+ /**
+ * Create a new FieldMatrix<T> using the input array as the underlying
+ * data array.
+ * <p>If an array is built specially in order to be embedded in a
+ * FieldMatrix<T> and not used directly, the <code>copyArray</code> may be
+ * set to <code>false</code. This will prevent the copying and improve
+ * performance as no new array will be built and no data will be copied.</p>
+ * @param d data for new matrix
+ * @param copyArray if true, the input array will be copied, otherwise
+ * it will be referenced
+ * @throws IllegalArgumentException if <code>d</code> is not rectangular
+ * (not all rows have the same length) or empty
+ * @throws NullPointerException if <code>d</code> is null
+ * @see #FieldMatrixImpl(T[][])
+ */
+ @SuppressWarnings("unchecked")
+ public FieldMatrixImpl(final T[][] d, final boolean copyArray)
+ throws IllegalArgumentException, NullPointerException {
+ super((Field<T>) extractField(d));
+ if (copyArray) {
+ copyIn(d);
+ } else {
+ if (d == null) {
+ throw new NullPointerException();
+ }
+ final int nRows = d.length;
+ if (nRows == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one row");
+ }
+ final int nCols = d[0].length;
+ if (nCols == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one column");
+ }
+ for (int r = 1; r < nRows; r++) {
+ if (d[r].length != nCols) {
+ throw MathRuntimeException.createIllegalArgumentException(
+ "some rows have length {0} while others have length {1}",
+ nCols, d[r].length);
+ }
+ }
+ data = d;
+ }
+ }
+
+ /**
+ * Create a new (column) FieldMatrix<T> using <code>v</code> as the
+ * data for the unique column of the <code>v.length x 1</code> matrix
+ * created.
+ * <p>The input array is copied, not referenced.</p>
+ *
+ * @param v column vector holding data for new matrix
+ */
+ @SuppressWarnings("unchecked")
+ public FieldMatrixImpl(final T[] v) {
+ super((Field<T>) extractField(v));
+ final int nRows = v.length;
+ data = buildArray(nRows, 1);
+ for (int row = 0; row < nRows; row++) {
+ data[row][0] = v[row];
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public FieldMatrix<T> createMatrix(final int rowDimension, final int columnDimension)
+ throws IllegalArgumentException {
+ return new FieldMatrixImpl<T>(getField(), rowDimension, columnDimension);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public FieldMatrix<T> copy() {
+ return new FieldMatrixImpl<T>(copyOut(), false);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public FieldMatrix<T> add(final FieldMatrix<T> m)
+ throws IllegalArgumentException {
+ try {
+ return add((FieldMatrixImpl<T>) m);
+ } catch (ClassCastException cce) {
+ return super.add(m);
+ }
+ }
+
+ /**
+ * Compute the sum of this and <code>m</code>.
+ *
+ * @param m matrix to be added
+ * @return this + m
+ * @throws IllegalArgumentException if m is not the same size as this
+ */
+ public FieldMatrixImpl<T> add(final FieldMatrixImpl<T> m)
+ throws IllegalArgumentException {
+
+ // safety check
+ checkAdditionCompatible(m);
+
+ final int rowCount = getRowDimension();
+ final int columnCount = getColumnDimension();
+ final T[][] outData = buildArray(rowCount, columnCount);
+ for (int row = 0; row < rowCount; row++) {
+ final T[] dataRow = data[row];
+ final T[] mRow = m.data[row];
+ final T[] outDataRow = outData[row];
+ for (int col = 0; col < columnCount; col++) {
+ outDataRow[col] = dataRow[col].add(mRow[col]);
+ }
+ }
+
+ return new FieldMatrixImpl<T>(outData, false);
+
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public FieldMatrix<T> subtract(final FieldMatrix<T> m)
+ throws IllegalArgumentException {
+ try {
+ return subtract((FieldMatrixImpl<T>) m);
+ } catch (ClassCastException cce) {
+ return super.subtract(m);
+ }
+ }
+
+ /**
+ * Compute this minus <code>m</code>.
+ *
+ * @param m matrix to be subtracted
+ * @return this + m
+ * @throws IllegalArgumentException if m is not the same size as this
+ */
+ public FieldMatrixImpl<T> subtract(final FieldMatrixImpl<T> m)
+ throws IllegalArgumentException {
+
+ // safety check
+ checkSubtractionCompatible(m);
+
+ final int rowCount = getRowDimension();
+ final int columnCount = getColumnDimension();
+ final T[][] outData = buildArray(rowCount, columnCount);
+ for (int row = 0; row < rowCount; row++) {
+ final T[] dataRow = data[row];
+ final T[] mRow = m.data[row];
+ final T[] outDataRow = outData[row];
+ for (int col = 0; col < columnCount; col++) {
+ outDataRow[col] = dataRow[col].subtract(mRow[col]);
+ }
+ }
+
+ return new FieldMatrixImpl<T>(outData, false);
+
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public FieldMatrix<T> multiply(final FieldMatrix<T> m)
+ throws IllegalArgumentException {
+ try {
+ return multiply((FieldMatrixImpl<T>) m);
+ } catch (ClassCastException cce) {
+ return super.multiply(m);
+ }
+ }
+
+ /**
+ * Returns the result of postmultiplying this by <code>m</code>.
+ * @param m matrix to postmultiply by
+ * @return this*m
+ * @throws IllegalArgumentException
+ * if columnDimension(this) != rowDimension(m)
+ */
+ public FieldMatrixImpl<T> multiply(final FieldMatrixImpl<T> m)
+ throws IllegalArgumentException {
+
+ // safety check
+ checkMultiplicationCompatible(m);
+
+ final int nRows = this.getRowDimension();
+ final int nCols = m.getColumnDimension();
+ final int nSum = this.getColumnDimension();
+ final T[][] outData = buildArray(nRows, nCols);
+ for (int row = 0; row < nRows; row++) {
+ final T[] dataRow = data[row];
+ final T[] outDataRow = outData[row];
+ for (int col = 0; col < nCols; col++) {
+ T sum = getField().getZero();
+ for (int i = 0; i < nSum; i++) {
+ sum = sum.add(dataRow[i].multiply(m.data[i][col]));
+ }
+ outDataRow[col] = sum;
+ }
+ }
+
+ return new FieldMatrixImpl<T>(outData, false);
+
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T[][] getData() {
+ return copyOut();
+ }
+
+ /**
+ * Returns a reference to the underlying data array.
+ * <p>
+ * Does <strong>not</strong> make a fresh copy of the underlying data.</p>
+ *
+ * @return 2-dimensional array of entries
+ */
+ public T[][] getDataRef() {
+ return data;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void setSubMatrix(final T[][] subMatrix, final int row, final int column)
+ throws MatrixIndexException {
+ if (data == null) {
+ if (row > 0) {
+ throw MathRuntimeException.createIllegalStateException(
+ "first {0} rows are not initialized yet",
+ row);
+ }
+ if (column > 0) {
+ throw MathRuntimeException.createIllegalStateException(
+ "first {0} columns are not initialized yet",
+ column);
+ }
+ final int nRows = subMatrix.length;
+ if (nRows == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one row");
+ }
+
+ final int nCols = subMatrix[0].length;
+ if (nCols == 0) {
+ throw MathRuntimeException.createIllegalArgumentException("matrix must have at least one column");
+ }
+ data = buildArray(subMatrix.length, nCols);
+ for (int i = 0; i < data.length; ++i) {
+ if (subMatrix[i].length != nCols) {
+ throw MathRuntimeException.createIllegalArgumentException(
+ "some rows have length {0} while others have length {1}",
+ nCols, subMatrix[i].length);
+ }
+ System.arraycopy(subMatrix[i], 0, data[i + row], column, nCols);
+ }
+ } else {
+ super.setSubMatrix(subMatrix, row, column);
+ }
+
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T getEntry(final int row, final int column)
+ throws MatrixIndexException {
+ try {
+ return data[row][column];
+ } catch (ArrayIndexOutOfBoundsException e) {
+ throw new MatrixIndexException(
+ "no entry at indices ({0}, {1}) in a {2}x{3} matrix",
+ row, column, getRowDimension(), getColumnDimension());
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void setEntry(final int row, final int column, final T value)
+ throws MatrixIndexException {
+ try {
+ data[row][column] = value;
+ } catch (ArrayIndexOutOfBoundsException e) {
+ throw new MatrixIndexException(
+ "no entry at indices ({0}, {1}) in a {2}x{3} matrix",
+ row, column, getRowDimension(), getColumnDimension());
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void addToEntry(final int row, final int column, final T increment)
+ throws MatrixIndexException {
+ try {
+ data[row][column] = data[row][column].add(increment);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ throw new MatrixIndexException(
+ "no entry at indices ({0}, {1}) in a {2}x{3} matrix",
+ row, column, getRowDimension(), getColumnDimension());
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void multiplyEntry(final int row, final int column, final T factor)
+ throws MatrixIndexException {
+ try {
+ data[row][column] = data[row][column].multiply(factor);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ throw new MatrixIndexException(
+ "no entry at indices ({0}, {1}) in a {2}x{3} matrix",
+ row, column, getRowDimension(), getColumnDimension());
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public int getRowDimension() {
+ return (data == null) ? 0 : data.length;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public int getColumnDimension() {
+ return ((data == null) || (data[0] == null)) ? 0 : data[0].length;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T[] operate(final T[] v)
+ throws IllegalArgumentException {
+ final int nRows = this.getRowDimension();
+ final int nCols = this.getColumnDimension();
+ if (v.length != nCols) {
+ throw MathRuntimeException.createIllegalArgumentException(
+ "vector length mismatch: got {0} but expected {1}",
+ v.length, nCols);
+ }
+ final T[] out = buildArray(nRows);
+ for (int row = 0; row < nRows; row++) {
+ final T[] dataRow = data[row];
+ T sum = getField().getZero();
+ for (int i = 0; i < nCols; i++) {
+ sum = sum.add(dataRow[i].multiply(v[i]));
+ }
+ out[row] = sum;
+ }
+ return out;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T[] preMultiply(final T[] v)
+ throws IllegalArgumentException {
+
+ final int nRows = getRowDimension();
+ final int nCols = getColumnDimension();
+ if (v.length != nRows) {
+ throw MathRuntimeException.createIllegalArgumentException(
+ "vector length mismatch: got {0} but expected {1}",
+ v.length, nRows);
+ }
+
+ final T[] out = buildArray(nCols);
+ for (int col = 0; col < nCols; ++col) {
+ T sum = getField().getZero();
+ for (int i = 0; i < nRows; ++i) {
+ sum = sum.add(data[i][col].multiply(v[i]));
+ }
+ out[col] = sum;
+ }
+
+ return out;
+
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor)
+ throws MatrixVisitorException {
+ final int rows = getRowDimension();
+ final int columns = getColumnDimension();
+ visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
+ for (int i = 0; i < rows; ++i) {
+ final T[] rowI = data[i];
+ for (int j = 0; j < columns; ++j) {
+ rowI[j] = visitor.visit(i, j, rowI[j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInRowOrder(final FieldMatrixPreservingVisitor<T> visitor)
+ throws MatrixVisitorException {
+ final int rows = getRowDimension();
+ final int columns = getColumnDimension();
+ visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
+ for (int i = 0; i < rows; ++i) {
+ final T[] rowI = data[i];
+ for (int j = 0; j < columns; ++j) {
+ visitor.visit(i, j, rowI[j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor,
+ final int startRow, final int endRow,
+ final int startColumn, final int endColumn)
+ throws MatrixIndexException, MatrixVisitorException {
+ checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
+ visitor.start(getRowDimension(), getColumnDimension(),
+ startRow, endRow, startColumn, endColumn);
+ for (int i = startRow; i <= endRow; ++i) {
+ final T[] rowI = data[i];
+ for (int j = startColumn; j <= endColumn; ++j) {
+ rowI[j] = visitor.visit(i, j, rowI[j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInRowOrder(final FieldMatrixPreservingVisitor<T> visitor,
+ final int startRow, final int endRow,
+ final int startColumn, final int endColumn)
+ throws MatrixIndexException, MatrixVisitorException {
+ checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
+ visitor.start(getRowDimension(), getColumnDimension(),
+ startRow, endRow, startColumn, endColumn);
+ for (int i = startRow; i <= endRow; ++i) {
+ final T[] rowI = data[i];
+ for (int j = startColumn; j <= endColumn; ++j) {
+ visitor.visit(i, j, rowI[j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInColumnOrder(final FieldMatrixChangingVisitor<T> visitor)
+ throws MatrixVisitorException {
+ final int rows = getRowDimension();
+ final int columns = getColumnDimension();
+ visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
+ for (int j = 0; j < columns; ++j) {
+ for (int i = 0; i < rows; ++i) {
+ final T[] rowI = data[i];
+ rowI[j] = visitor.visit(i, j, rowI[j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInColumnOrder(final FieldMatrixPreservingVisitor<T> visitor)
+ throws MatrixVisitorException {
+ final int rows = getRowDimension();
+ final int columns = getColumnDimension();
+ visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
+ for (int j = 0; j < columns; ++j) {
+ for (int i = 0; i < rows; ++i) {
+ visitor.visit(i, j, data[i][j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInColumnOrder(final FieldMatrixChangingVisitor<T> visitor,
+ final int startRow, final int endRow,
+ final int startColumn, final int endColumn)
+ throws MatrixIndexException, MatrixVisitorException {
+ checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
+ visitor.start(getRowDimension(), getColumnDimension(),
+ startRow, endRow, startColumn, endColumn);
+ for (int j = startColumn; j <= endColumn; ++j) {
+ for (int i = startRow; i <= endRow; ++i) {
+ final T[] rowI = data[i];
+ rowI[j] = visitor.visit(i, j, rowI[j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public T walkInColumnOrder(final FieldMatrixPreservingVisitor<T> visitor,
+ final int startRow, final int endRow,
+ final int startColumn, final int endColumn)
+ throws MatrixIndexException, MatrixVisitorException {
+ checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
+ visitor.start(getRowDimension(), getColumnDimension(),
+ startRow, endRow, startColumn, endColumn);
+ for (int j = startColumn; j <= endColumn; ++j) {
+ for (int i = startRow; i <= endRow; ++i) {
+ visitor.visit(i, j, data[i][j]);
+ }
+ }
+ return visitor.end();
+ }
+
+ /**
+ * Returns a fresh copy of the underlying data array.
+ *
+ * @return a copy of the underlying data array.
+ */
+ private T[][] copyOut() {
+ final int nRows = this.getRowDimension();
+ final T[][] out = buildArray(nRows, getColumnDimension());
+ // can't copy 2-d array in one shot, otherwise get row references
+ for (int i = 0; i < nRows; i++) {
+ System.arraycopy(data[i], 0, out[i], 0, data[i].length);
+ }
+ return out;
+ }
+
+ /**
+ * Replaces data with a fresh copy of the input array.
+ * <p>
+ * Verifies that the input array is rectangular and non-empty.</p>
+ *
+ * @param in data to copy in
+ * @throws IllegalArgumentException if input array is empty or not
+ * rectangular
+ * @throws NullPointerException if input array is null
+ */
+ private void copyIn(final T[][] in) {
+ setSubMatrix(in, 0, 0);
+ }
+
+}
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixImpl.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixImpl.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixPreservingVisitor.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixPreservingVisitor.java?rev=766485&view=auto
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixPreservingVisitor.java (added)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixPreservingVisitor.java Sun Apr 19 16:39:40 2009
@@ -0,0 +1,63 @@
+/*
+ * 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.commons.math.linear;
+
+import java.io.Serializable;
+
+import org.apache.commons.math.FieldElement;
+
+/**
+ * Interface defining a visitor for matrix entries.
+ *
+ * @param <T> the type of the field elements
+ * @version $Revision$ $Date$
+ * @since 2.0
+ */
+public interface FieldMatrixPreservingVisitor<T extends FieldElement<?>> extends Serializable {
+
+ /**
+ * Start visiting a matrix.
+ * <p>This method is called once before any entry of the matrix is visited.</p>
+ * @param rows number of rows of the matrix
+ * @param columns number of columns of the matrix
+ * @param startRow Initial row index
+ * @param endRow Final row index (inclusive)
+ * @param startColumn Initial column index
+ * @param endColumn Final column index (inclusive)
+ */
+ void start(int rows, int columns,
+ int startRow, int endRow, int startColumn, int endColumn);
+
+ /**
+ * Visit one matrix entry.
+ * @param row row index of the entry
+ * @param column column index of the entry
+ * @param value current value of the entry
+ * @throws MatrixVisitorException if something wrong occurs
+ */
+ void visit(int row, int column, T value)
+ throws MatrixVisitorException;
+
+ /**
+ * End visiting a matrix.
+ * <p>This method is called once after all entries of the matrix have been visited.</p>
+ * @return the value that the <code>walkInXxxOrder</code> must return
+ */
+ T end();
+
+}
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixPreservingVisitor.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldMatrixPreservingVisitor.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldVector.java?rev=766485&view=auto
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldVector.java (added)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldVector.java Sun Apr 19 16:39:40 2009
@@ -0,0 +1,364 @@
+/*
+ * 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.commons.math.linear;
+
+import java.io.Serializable;
+
+import org.apache.commons.math.Field;
+import org.apache.commons.math.FieldElement;
+
+/**
+ * Interface defining a field-valued vector with basic algebraic operations.
+ * <p>
+ * vector element indexing is 0-based -- e.g., <code>getEntry(0)</code>
+ * returns the first element of the vector.
+ * </p>
+ * <p>
+ * The various <code>mapXxx</code> and <code>mapXxxToSelf</code> methods operate
+ * on vectors element-wise, i.e. they perform the same operation (adding a scalar,
+ * applying a function ...) on each element in turn. The <code>mapXxx</code>
+ * versions create a new vector to hold the result and do not change the instance.
+ * The <code>mapXxxToSelf</code> versions use the instance itself to store the
+ * results, so the instance is changed by these methods. In both cases, the result
+ * vector is returned by the methods, this allows to use the <i>fluent API</i>
+ * style, like this:
+ * </p>
+ * <pre>
+ * RealVector result = v.mapAddToSelf(3.0).mapTanToSelf().mapSquareToSelf();
+ * </pre>
+ *
+ * @param <T> the type of the field elements
+ * @version $Revision$ $Date$
+ * @since 2.0
+ */
+public interface FieldVector<T extends FieldElement<T>> extends Serializable {
+
+ /**
+ * Get the type of field elements of the vector.
+ * @return type of field elements of the vector
+ */
+ Field<T> getField();
+
+ /**
+ * Returns a (deep) copy of this.
+ * @return vector copy
+ */
+ FieldVector<T> copy();
+
+ /**
+ * Compute the sum of this and v.
+ * @param v vector to be added
+ * @return this + v
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ FieldVector<T> add(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /**
+ * Compute the sum of this and v.
+ * @param v vector to be added
+ * @return this + v
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ FieldVector<T> add(T[] v)
+ throws IllegalArgumentException;
+
+ /**
+ * Compute this minus v.
+ * @param v vector to be subtracted
+ * @return this + v
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ FieldVector<T> subtract(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /**
+ * Compute this minus v.
+ * @param v vector to be subtracted
+ * @return this + v
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ FieldVector<T> subtract(T[] v)
+ throws IllegalArgumentException;
+
+ /**
+ * Map an addition operation to each entry.
+ * @param d value to be added to each entry
+ * @return this + d
+ */
+ FieldVector<T> mapAdd(T d);
+
+ /**
+ * Map an addition operation to each entry.
+ * <p>The instance <strong>is</strong> changed by this method.</p>
+ * @param d value to be added to each entry
+ * @return for convenience, return this
+ */
+ FieldVector<T> mapAddToSelf(T d);
+
+ /**
+ * Map a subtraction operation to each entry.
+ * @param d value to be subtracted to each entry
+ * @return this - d
+ */
+ FieldVector<T> mapSubtract(T d);
+
+ /**
+ * Map a subtraction operation to each entry.
+ * <p>The instance <strong>is</strong> changed by this method.</p>
+ * @param d value to be subtracted to each entry
+ * @return for convenience, return this
+ */
+ FieldVector<T> mapSubtractToSelf(T d);
+
+ /**
+ * Map a multiplication operation to each entry.
+ * @param d value to multiply all entries by
+ * @return this * d
+ */
+ FieldVector<T> mapMultiply(T d);
+
+ /**
+ * Map a multiplication operation to each entry.
+ * <p>The instance <strong>is</strong> changed by this method.</p>
+ * @param d value to multiply all entries by
+ * @return for convenience, return this
+ */
+ FieldVector<T> mapMultiplyToSelf(T d);
+
+ /**
+ * Map a division operation to each entry.
+ * @param d value to divide all entries by
+ * @return this / d
+ */
+ FieldVector<T> mapDivide(T d);
+
+ /**
+ * Map a division operation to each entry.
+ * <p>The instance <strong>is</strong> changed by this method.</p>
+ * @param d value to divide all entries by
+ * @return for convenience, return this
+ */
+ FieldVector<T> mapDivideToSelf(T d);
+
+ /**
+ * Map the 1/x function to each entry.
+ * @return a vector containing the result of applying the function to each entry
+ */
+ FieldVector<T> mapInv();
+
+ /**
+ * Map the 1/x function to each entry.
+ * <p>The instance <strong>is</strong> changed by this method.</p>
+ * @return for convenience, return this
+ */
+ FieldVector<T> mapInvToSelf();
+
+ /**
+ * Element-by-element multiplication.
+ * @param v vector by which instance elements must be multiplied
+ * @return a vector containing this[i] * v[i] for all i
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ public FieldVector<T> ebeMultiply(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /**
+ * Element-by-element multiplication.
+ * @param v vector by which instance elements must be multiplied
+ * @return a vector containing this[i] * v[i] for all i
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ public FieldVector<T> ebeMultiply(T[] v)
+ throws IllegalArgumentException;
+
+ /**
+ * Element-by-element division.
+ * @param v vector by which instance elements must be divided
+ * @return a vector containing this[i] / v[i] for all i
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ public FieldVector<T> ebeDivide(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /**
+ * Element-by-element division.
+ * @param v vector by which instance elements must be divided
+ * @return a vector containing this[i] / v[i] for all i
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ public FieldVector<T> ebeDivide(T[] v)
+ throws IllegalArgumentException;
+
+ /**
+ * Returns vector entries as a T array.
+ * @return T array of entries
+ */
+ T[] getData();
+
+ /**
+ * Compute the dot product.
+ * @param v vector with which dot product should be computed
+ * @return the scalar dot product between instance and v
+ * @exception IllegalArgumentException if v is not the same size as this
+ */
+ T dotProduct(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /**
+ * Compute the dot product.
+ * @param v vector with which dot product should be computed
+ * @return the scalar dot product between instance and v
+ * @exception IllegalArgumentException if v is not the same size as this
+ */
+ T dotProduct(T[] v)
+ throws IllegalArgumentException;
+
+ /** Find the orthogonal projection of this vector onto another vector.
+ * @param v vector onto which instance must be projected
+ * @return projection of the instance onto v
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ FieldVector<T> projection(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /** Find the orthogonal projection of this vector onto another vector.
+ * @param v vector onto which instance must be projected
+ * @return projection of the instance onto v
+ * @throws IllegalArgumentException if v is not the same size as this
+ */
+ FieldVector<T> projection(T[] v)
+ throws IllegalArgumentException;
+
+ /**
+ * Compute the outer product.
+ * @param v vector with which outer product should be computed
+ * @return the square matrix outer product between instance and v
+ * @exception IllegalArgumentException if v is not the same size as this
+ */
+ FieldMatrix<T> outerProduct(FieldVector<T> v)
+ throws IllegalArgumentException;
+
+ /**
+ * Compute the outer product.
+ * @param v vector with which outer product should be computed
+ * @return the square matrix outer product between instance and v
+ * @exception IllegalArgumentException if v is not the same size as this
+ */
+ FieldMatrix<T> outerProduct(T[] v)
+ throws IllegalArgumentException;
+
+ /**
+ * Returns the entry in the specified index.
+ * <p>
+ * The index start at 0 and must be lesser than the size,
+ * otherwise a {@link MatrixIndexException} is thrown.
+ * </p>
+ * @param index index location of entry to be fetched
+ * @return vector entry at index
+ * @throws MatrixIndexException if the index is not valid
+ * @see #setEntry(int, T)
+ */
+ T getEntry(int index)
+ throws MatrixIndexException;
+
+ /**
+ * Set a single element.
+ * @param index element index.
+ * @param value new value for the element.
+ * @exception MatrixIndexException if the index is
+ * inconsistent with vector size
+ * @see #getEntry(int)
+ */
+ void setEntry(int index, T value)
+ throws MatrixIndexException;
+
+ /**
+ * Returns the size of the vector.
+ * @return size
+ */
+ int getDimension();
+
+ /**
+ * Construct a vector by appending a vector to this vector.
+ * @param v vector to append to this one.
+ * @return a new vector
+ */
+ FieldVector<T> append(FieldVector<T> v);
+
+ /**
+ * Construct a vector by appending a T to this vector.
+ * @param d T to append.
+ * @return a new vector
+ */
+ FieldVector<T> append(T d);
+
+ /**
+ * Construct a vector by appending a T array to this vector.
+ * @param a T array to append.
+ * @return a new vector
+ */
+ FieldVector<T> append(T[] a);
+
+ /**
+ * Get a subvector from consecutive elements.
+ * @param index index of first element.
+ * @param n number of elements to be retrieved.
+ * @return a vector containing n elements.
+ * @exception MatrixIndexException if the index is
+ * inconsistent with vector size
+ */
+ FieldVector<T> getSubVector(int index, int n)
+ throws MatrixIndexException;
+
+ /**
+ * Set a set of consecutive elements.
+ * @param index index of first element to be set.
+ * @param v vector containing the values to set.
+ * @exception MatrixIndexException if the index is
+ * inconsistent with vector size
+ * @see #setSubVector(int, T[])
+ */
+ void setSubVector(int index, FieldVector<T> v)
+ throws MatrixIndexException;
+
+ /**
+ * Set a set of consecutive elements.
+ * @param index index of first element to be set.
+ * @param v vector containing the values to set.
+ * @exception MatrixIndexException if the index is
+ * inconsistent with vector size
+ * @see #setSubVector(int, FieldVector)
+ */
+ void setSubVector(int index, T[] v)
+ throws MatrixIndexException;
+
+ /**
+ * Set all elements to a single value.
+ * @param value single value to set for all elements
+ */
+ void set(T value);
+
+ /**
+ * Convert the vector to a T array.
+ * <p>The array is independent from vector data, it's elements
+ * are copied.</p>
+ * @return array containing a copy of vector elements
+ */
+ T[] toArray();
+
+}
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldVector.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/trunk/src/java/org/apache/commons/math/linear/FieldVector.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision