Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
org.apache.commons.math.FieldElement

Packages that use FieldElement
org.apache.commons.math.complex | Complex number type and implementations of complex transcendental functions.
org.apache.commons.math.dfp | Decimal floating point library for Java
org.apache.commons.math.fraction | Fraction number type and fraction number formatting.
org.apache.commons.math.linear | Linear algebra support.
org.apache.commons.math.util | Convenience routines and common data structures used throughout the commons-math library.

Uses of FieldElement in org.apache.commons.math.complex

Classes in org.apache.commons.math.complex that implement FieldElement
`class` | `Complex` Representation of a Complex number - a number which has both a real and imaginary part.

Uses of FieldElement in org.apache.commons.math.dfp

Classes in org.apache.commons.math.dfp that implement FieldElement
`class` | `Dfp` Decimal floating point library for Java
`class` | `DfpDec` Subclass of `Dfp` which hides the radix-10000 artifacts of the superclass.

Uses of FieldElement in org.apache.commons.math.fraction

Classes in org.apache.commons.math.fraction that implement FieldElement
`class` | `BigFraction` Representation of a rational number without any overflow.
`class` | `Fraction` Representation of a rational number.

Uses of FieldElement in org.apache.commons.math.linear

Classes in org.apache.commons.math.linear with type parameters of type FieldElement
`class` | `AbstractFieldMatrix<T extends FieldElement<T>>` Basic implementation of `FieldMatrix` methods regardless of the underlying storage.
`class` | `Array2DRowFieldMatrix<T extends FieldElement<T>>` Implementation of FieldMatrix using a `FieldElement`[][] array to store entries.
`class` | `ArrayFieldVector<T extends FieldElement<T>>` This class implements the `FieldVector` interface with a `FieldElement` array.
`class` | `BlockFieldMatrix<T extends FieldElement<T>>` Cache-friendly implementation of FieldMatrix using a flat arrays to store square blocks of the matrix.
`class` | `DefaultFieldMatrixChangingVisitor<T extends FieldElement<T>>` Default implementation of the `FieldMatrixChangingVisitor` interface.
`class` | `DefaultFieldMatrixPreservingVisitor<T extends FieldElement<T>>` Default implementation of the `FieldMatrixPreservingVisitor` interface.
`interface` | `FieldDecompositionSolver<T extends FieldElement<T>>` Interface handling decomposition algorithms that can solve A × X = B.
`interface` | `FieldLUDecomposition<T extends FieldElement<T>>` An interface to classes that implement an algorithm to calculate the LU-decomposition of a real matrix.
`class` | `FieldLUDecompositionImpl<T extends FieldElement<T>>` Calculates the LUP-decomposition of a square matrix.
`interface` | `FieldMatrix<T extends FieldElement<T>>` Interface defining field-valued matrix with basic algebraic operations.
`interface` | `FieldMatrixChangingVisitor<T extends FieldElement<?>>` Interface defining a visitor for matrix entries.
`interface` | `FieldMatrixPreservingVisitor<T extends FieldElement<?>>` Interface defining a visitor for matrix entries.
`interface` | `FieldVector<T extends FieldElement<T>>` Interface defining a field-valued vector with basic algebraic operations.
`class` | `SparseFieldMatrix<T extends FieldElement<T>>` Sparse matrix implementation based on an open addressed map.
`class` | `SparseFieldVector<T extends FieldElement<T>>` This class implements the `FieldVector` interface with a `OpenIntToFieldHashMap` backing store.

Fields in org.apache.commons.math.linear declared as FieldElement
`protected T[][]` | `Array2DRowFieldMatrix.data` Entries of the matrix
`protected T[]` | `ArrayFieldVector.data` Entries of the vector.

Methods in org.apache.commons.math.linear with type parameters of type FieldElement
`protected static
`<T extends FieldElement<T>> T[]`
` | `AbstractFieldMatrix.buildArray(Field<T> field, int length)` Build an array of elements.
`protected static
`<T extends FieldElement<T>> T[][]`
` | `AbstractFieldMatrix.buildArray(Field<T> field, int rows, int columns)` Build an array of elements.
`static
`<T extends FieldElement<T>> T[][]`
` | `BlockFieldMatrix.createBlocksLayout(Field<T> field, int rows, int columns)` Create a data array in blocks layout.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createColumnFieldMatrix(T[] columnData)` Creates a column `FieldMatrix` using the data from the input array.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldDiagonalMatrix(T[] diagonal)` Returns a diagonal matrix with specified elements.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldIdentityMatrix(Field<T> field, int dimension)` Returns `dimension x dimension` identity matrix.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldMatrix(Field<T> field, int rows, int columns)` Returns a `FieldMatrix` with specified dimensions.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldMatrix(T[][] data)` Returns a `FieldMatrix` whose entries are the the values in the the input array.
`static
`<T extends FieldElement<T>> FieldVector<T>`
` | `MatrixUtils.createFieldVector(T[] data)` Creates a `FieldVector` using the data from the input array.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createRowFieldMatrix(T[] rowData)` Creates a row `FieldMatrix` using the data from the input array.
`protected static
`<T extends FieldElement<T>> Field<T>`
` | `AbstractFieldMatrix.extractField(T[] d)` Get the elements type from an array.
`protected static
`<T extends FieldElement<T>> Field<T>`
` | `AbstractFieldMatrix.extractField(T[][] d)` Get the elements type from an array.
`static
`<T extends FieldElement<T>> T[][]`
` | `BlockFieldMatrix.toBlocksLayout(T[][] rawData)` Convert a data array from raw layout to blocks layout.

Methods in org.apache.commons.math.linear that return FieldElement
`protected static
`<T extends FieldElement<T>> T[]`
` | `AbstractFieldMatrix.buildArray(Field<T> field, int length)` Build an array of elements.
`protected static
`<T extends FieldElement<T>> T[][]`
` | `AbstractFieldMatrix.buildArray(Field<T> field, int rows, int columns)` Build an array of elements.
`static
`<T extends FieldElement<T>> T[][]`
` | `BlockFieldMatrix.createBlocksLayout(Field<T> field, int rows, int columns)` Create a data array in blocks layout.
`T[]` | `FieldMatrix.getColumn(int column)` Returns the entries in column number `col` as an array.
`T[]` | `BlockFieldMatrix.getColumn(int column)` Returns the entries in column number `col` as an array.
`T[]` | `AbstractFieldMatrix.getColumn(int column)` Returns the entries in column number `col` as an array.
`T[][]` | `FieldMatrix.getData()` Returns matrix entries as a two-dimensional array.
`T[][]` | `BlockFieldMatrix.getData()` Returns matrix entries as a two-dimensional array.
`T[]` | `SparseFieldVector.getData()` Returns vector entries as a T array.
`T[]` | `FieldVector.getData()` Returns vector entries as a T array.
`T[][]` | `Array2DRowFieldMatrix.getData()` Returns matrix entries as a two-dimensional array.
`T[]` | `ArrayFieldVector.getData()` Returns vector entries as a T array.
`T[][]` | `AbstractFieldMatrix.getData()` Returns matrix entries as a two-dimensional array.
`T[][]` | `Array2DRowFieldMatrix.getDataRef()` Returns a reference to the underlying data array.
`T[]` | `ArrayFieldVector.getDataRef()` Returns a reference to the underlying data array.
`T[]` | `FieldMatrix.getRow(int row)` Returns the entries in row number `row` as an array.
`T[]` | `BlockFieldMatrix.getRow(int row)` Returns the entries in row number `row` as an array.
`T[]` | `AbstractFieldMatrix.getRow(int row)` Returns the entries in row number `row` as an array.
`T[]` | `FieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `BlockFieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `Array2DRowFieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `AbstractFieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `FieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `BlockFieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `Array2DRowFieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `AbstractFieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `FieldDecompositionSolver.solve(T[] b)` Solve the linear equation A × X = B for matrices A.
`T[]` | `SparseFieldVector.toArray()` Convert the vector to a T array.
`T[]` | `FieldVector.toArray()` Convert the vector to a T array.
`T[]` | `ArrayFieldVector.toArray()` Convert the vector to a T array.
`static
`<T extends FieldElement<T>> T[][]`
` | `BlockFieldMatrix.toBlocksLayout(T[][] rawData)` Convert a data array from raw layout to blocks layout.

Methods in org.apache.commons.math.linear with parameters of type FieldElement
`FieldVector<T>` | `SparseFieldVector.add(T[] v)` Compute the sum of this and v.
`FieldVector<T>` | `FieldVector.add(T[] v)` Compute the sum of this and v.
`FieldVector<T>` | `ArrayFieldVector.add(T[] v)` Compute the sum of this and v.
`FieldVector<T>` | `SparseFieldVector.append(T[] a)` Construct a vector by appending a T array to this vector.
`FieldVector<T>` | `FieldVector.append(T[] a)` Construct a vector by appending a T array to this vector.
`FieldVector<T>` | `ArrayFieldVector.append(T[] in)` Construct a vector by appending a T array to this vector.
`void` | `FieldMatrix.copySubMatrix(int[] selectedRows, int[] selectedColumns, T[][] destination)` Copy a submatrix.
`void` | `AbstractFieldMatrix.copySubMatrix(int[] selectedRows, int[] selectedColumns, T[][] destination)` Copy a submatrix.
`void` | `FieldMatrix.copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, T[][] destination)` Copy a submatrix.
`void` | `AbstractFieldMatrix.copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, T[][] destination)` Copy a submatrix.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createColumnFieldMatrix(T[] columnData)` Creates a column `FieldMatrix` using the data from the input array.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldDiagonalMatrix(T[] diagonal)` Returns a diagonal matrix with specified elements.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldMatrix(T[][] data)` Returns a `FieldMatrix` whose entries are the the values in the the input array.
`static
`<T extends FieldElement<T>> FieldVector<T>`
` | `MatrixUtils.createFieldVector(T[] data)` Creates a `FieldVector` using the data from the input array.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createRowFieldMatrix(T[] rowData)` Creates a row `FieldMatrix` using the data from the input array.
`T` | `SparseFieldVector.dotProduct(T[] v)` Compute the dot product.
`T` | `FieldVector.dotProduct(T[] v)` Compute the dot product.
`T` | `ArrayFieldVector.dotProduct(T[] v)` Compute the dot product.
`FieldVector<T>` | `SparseFieldVector.ebeDivide(T[] v)` Element-by-element division.
`FieldVector<T>` | `FieldVector.ebeDivide(T[] v)` Element-by-element division.
`FieldVector<T>` | `ArrayFieldVector.ebeDivide(T[] v)` Element-by-element division.
`FieldVector<T>` | `SparseFieldVector.ebeMultiply(T[] v)` Element-by-element multiplication.
`FieldVector<T>` | `FieldVector.ebeMultiply(T[] v)` Element-by-element multiplication.
`FieldVector<T>` | `ArrayFieldVector.ebeMultiply(T[] v)` Element-by-element multiplication.
`protected static
`<T extends FieldElement<T>> Field<T>`
` | `AbstractFieldMatrix.extractField(T[] d)` Get the elements type from an array.
`protected static
`<T extends FieldElement<T>> Field<T>`
` | `AbstractFieldMatrix.extractField(T[][] d)` Get the elements type from an array.
`T[]` | `FieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `BlockFieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `Array2DRowFieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`T[]` | `AbstractFieldMatrix.operate(T[] v)` Returns the result of multiplying this by the vector `v`.
`FieldMatrix<T>` | `SparseFieldVector.outerProduct(T[] v)` Compute the outer product.
`FieldMatrix<T>` | `FieldVector.outerProduct(T[] v)` Compute the outer product.
`FieldMatrix<T>` | `ArrayFieldVector.outerProduct(T[] v)` Compute the outer product.
`T[]` | `FieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `BlockFieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `Array2DRowFieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]` | `AbstractFieldMatrix.preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
`FieldVector<T>` | `SparseFieldVector.projection(T[] v)` Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>` | `FieldVector.projection(T[] v)` Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>` | `ArrayFieldVector.projection(T[] v)` Find the orthogonal projection of this vector onto another vector.
`void` | `FieldMatrix.setColumn(int column, T[] array)` Sets the entries in column number `column` as a column matrix.
`void` | `BlockFieldMatrix.setColumn(int column, T[] array)` Sets the entries in column number `column` as a column matrix.
`void` | `AbstractFieldMatrix.setColumn(int column, T[] array)` Sets the entries in column number `column` as a column matrix.
`void` | `FieldMatrix.setRow(int row, T[] array)` Sets the entries in row number `row` as a row matrix.
`void` | `BlockFieldMatrix.setRow(int row, T[] array)` Sets the entries in row number `row` as a row matrix.
`void` | `AbstractFieldMatrix.setRow(int row, T[] array)` Sets the entries in row number `row` as a row matrix.
`void` | `FieldMatrix.setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void` | `BlockFieldMatrix.setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void` | `Array2DRowFieldMatrix.setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void` | `AbstractFieldMatrix.setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void` | `SparseFieldVector.setSubVector(int index, T[] v)` Set a set of consecutive elements.
`void` | `FieldVector.setSubVector(int index, T[] v)` Set a set of consecutive elements.
`void` | `ArrayFieldVector.setSubVector(int index, T[] v)` Set a set of consecutive elements.
`T[]` | `FieldDecompositionSolver.solve(T[] b)` Solve the linear equation A × X = B for matrices A.
`FieldVector<T>` | `SparseFieldVector.subtract(T[] v)` Compute this minus v.
`FieldVector<T>` | `FieldVector.subtract(T[] v)` Compute this minus v.
`FieldVector<T>` | `ArrayFieldVector.subtract(T[] v)` Compute this minus v.
`static
`<T extends FieldElement<T>> T[][]`
` | `BlockFieldMatrix.toBlocksLayout(T[][] rawData)` Convert a data array from raw layout to blocks layout.

Constructors in org.apache.commons.math.linear with parameters of type FieldElement
`Array2DRowFieldMatrix(T[] v)` Create a new (column) FieldMatrix using `v` as the data for the unique column of the `v.length x 1` matrix created.
`Array2DRowFieldMatrix(T[][] d)` Create a new FieldMatrix using the input array as the underlying data array.
`Array2DRowFieldMatrix(T[][] d, boolean copyArray)` Create a new FieldMatrix using the input array as the underlying data array.
`ArrayFieldVector(ArrayFieldVector<T> v1, T[] v2)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(Field<T> field, T[] d)` Construct a vector from an array, copying the input array.
`ArrayFieldVector(Field<T> field, T[] d, boolean copyArray)` Create a new ArrayFieldVector using the input array as the underlying data array.
`ArrayFieldVector(Field<T> field, T[] v1, T[] v2)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(Field<T> field, T[] v1, T[] v2)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(T[] d)` Construct a vector from an array, copying the input array.
`ArrayFieldVector(T[] v1, ArrayFieldVector<T> v2)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(T[] d, boolean copyArray)` Create a new ArrayFieldVector using the input array as the underlying data array.
`ArrayFieldVector(T[] d, int pos, int size)` Construct a vector from part of a array.
`ArrayFieldVector(T[] v1, T[] v2)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(T[] v1, T[] v2)` Construct a vector by appending one vector to another vector.
`BlockFieldMatrix(int rows, int columns, T[][] blockData, boolean copyArray)` Create a new dense matrix copying entries from block layout data.
`BlockFieldMatrix(T[][] rawData)` Create a new dense matrix copying entries from raw layout data.
`SparseFieldVector(Field<T> field, T[] values)` Create from a Field array.

Uses of FieldElement in org.apache.commons.math.util

Classes in org.apache.commons.math.util with type parameters of type FieldElement
`class` | `OpenIntToFieldHashMap<T extends FieldElement<T>>` Open addressed map from int to FieldElement.

Classes in org.apache.commons.math.util that implement FieldElement
`class` | `BigReal` Arbitrary precision decimal number.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2003-2011 The Apache Software Foundation. All Rights Reserved.