/**
* Returns a diagonal matrix with specified elements.
*
* @param <T> the type of the field elements
* @param diagonal diagonal elements of the matrix (the array elements will be copied)
* @return diagonal matrix
* @since 2.0
*/
public static <T extends FieldElement<T>> FieldMatrix<T> createFieldDiagonalMatrix(
final T[] diagonal) {
final FieldMatrix<T> m =
createFieldMatrix(diagonal[0].getField(), diagonal.length, diagonal.length);
for (int i = 0; i < diagonal.length; ++i) {
m.setEntry(i, i, diagonal[i]);
}
return m;
}
/**
* 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
*/
public FieldMatrix<T> outerProduct(ArrayFieldVector<T> v) {
final int m = data.length;
final int n = v.data.length;
final FieldMatrix<T> out = new Array2DRowFieldMatrix<T>(field, m, n);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
out.setEntry(i, j, data[i].multiply(v.data[j]));
}
}
return out;
}
/**
* Creates a row {@link FieldMatrix} using the data from the input array.
*
* @param <T> the type of the field elements
* @param rowData the input row data
* @return a 1 x rowData.length FieldMatrix
* @throws IllegalArgumentException if <code>rowData</code> is empty
* @throws NullPointerException if <code>rowData</code>is null
*/
public static <T extends FieldElement<T>> FieldMatrix<T> createRowFieldMatrix(final T[] rowData) {
final int nCols = rowData.length;
if (nCols == 0) {
throw MathRuntimeException.createIllegalArgumentException(
"matrix must have at least one column");
}
final FieldMatrix<T> m = createFieldMatrix(rowData[0].getField(), 1, nCols);
for (int i = 0; i < nCols; ++i) {
m.setEntry(0, i, rowData[i]);
}
return m;
}
/**
* Creates a column {@link FieldMatrix} using the data from the input array.
*
* @param <T> the type of the field elements
* @param columnData the input column data
* @return a columnData x 1 FieldMatrix
* @throws IllegalArgumentException if <code>columnData</code> is empty
* @throws NullPointerException if <code>columnData</code>is null
*/
public static <T extends FieldElement<T>> FieldMatrix<T> createColumnFieldMatrix(
final T[] columnData) {
final int nRows = columnData.length;
if (nRows == 0) {
throw MathRuntimeException.createIllegalArgumentException(
"matrix must have at least one row");
}
final FieldMatrix<T> m = createFieldMatrix(columnData[0].getField(), nRows, 1);
for (int i = 0; i < nRows; ++i) {
m.setEntry(i, 0, columnData[i]);
}
return m;
}
/** {@inheritDoc} */
public FieldMatrix<T> outerProduct(FieldVector<T> v) {
try {
return outerProduct((ArrayFieldVector<T>) v);
} catch (ClassCastException cce) {
final int m = data.length;
final int n = v.getDimension();
final FieldMatrix<T> out = new Array2DRowFieldMatrix<T>(field, m, n);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
out.setEntry(i, j, data[i].multiply(v.getEntry(j)));
}
}
return out;
}
}
@Test
public void testOuterProduct() {
final ArrayFieldVector<Fraction> u =
new ArrayFieldVector<Fraction>(
FractionField.getInstance(),
new Fraction[] {new Fraction(1), new Fraction(2), new Fraction(-3)});
final ArrayFieldVector<Fraction> v =
new ArrayFieldVector<Fraction>(
FractionField.getInstance(), new Fraction[] {new Fraction(4), new Fraction(-2)});
final FieldMatrix<Fraction> uv = u.outerProduct(v);
final double tol = Math.ulp(1d);
Assert.assertEquals(new Fraction(4).doubleValue(), uv.getEntry(0, 0).doubleValue(), tol);
Assert.assertEquals(new Fraction(-2).doubleValue(), uv.getEntry(0, 1).doubleValue(), tol);
Assert.assertEquals(new Fraction(8).doubleValue(), uv.getEntry(1, 0).doubleValue(), tol);
Assert.assertEquals(new Fraction(-4).doubleValue(), uv.getEntry(1, 1).doubleValue(), tol);
Assert.assertEquals(new Fraction(-12).doubleValue(), uv.getEntry(2, 0).doubleValue(), tol);
Assert.assertEquals(new Fraction(6).doubleValue(), uv.getEntry(2, 1).doubleValue(), tol);
}
@Test
public void testBasicFunctions() {
ArrayFieldVector<Fraction> v1 = new ArrayFieldVector<Fraction>(vec1);
ArrayFieldVector<Fraction> v2 = new ArrayFieldVector<Fraction>(vec2);
new ArrayFieldVector<Fraction>(vec_null);
FieldVectorTestImpl<Fraction> v2_t = new FieldVectorTestImpl<Fraction>(vec2);
// octave = v1 + v2
ArrayFieldVector<Fraction> v_add = v1.add(v2);
Fraction[] result_add = {new Fraction(5), new Fraction(7), new Fraction(9)};
checkArray("compare vect", v_add.getData(), result_add);
FieldVectorTestImpl<Fraction> vt2 = new FieldVectorTestImpl<Fraction>(vec2);
FieldVector<Fraction> v_add_i = v1.add(vt2);
Fraction[] result_add_i = {new Fraction(5), new Fraction(7), new Fraction(9)};
checkArray("compare vect", v_add_i.getData(), result_add_i);
// octave = v1 - v2
ArrayFieldVector<Fraction> v_subtract = v1.subtract(v2);
Fraction[] result_subtract = {new Fraction(-3), new Fraction(-3), new Fraction(-3)};
checkArray("compare vect", v_subtract.getData(), result_subtract);
FieldVector<Fraction> v_subtract_i = v1.subtract(vt2);
Fraction[] result_subtract_i = {new Fraction(-3), new Fraction(-3), new Fraction(-3)};
checkArray("compare vect", v_subtract_i.getData(), result_subtract_i);
// octave v1 .* v2
ArrayFieldVector<Fraction> v_ebeMultiply = v1.ebeMultiply(v2);
Fraction[] result_ebeMultiply = {new Fraction(4), new Fraction(10), new Fraction(18)};
checkArray("compare vect", v_ebeMultiply.getData(), result_ebeMultiply);
FieldVector<Fraction> v_ebeMultiply_2 = v1.ebeMultiply(v2_t);
Fraction[] result_ebeMultiply_2 = {new Fraction(4), new Fraction(10), new Fraction(18)};
checkArray("compare vect", v_ebeMultiply_2.getData(), result_ebeMultiply_2);
// octave v1 ./ v2
ArrayFieldVector<Fraction> v_ebeDivide = v1.ebeDivide(v2);
Fraction[] result_ebeDivide = {new Fraction(1, 4), new Fraction(2, 5), new Fraction(1, 2)};
checkArray("compare vect", v_ebeDivide.getData(), result_ebeDivide);
FieldVector<Fraction> v_ebeDivide_2 = v1.ebeDivide(v2_t);
Fraction[] result_ebeDivide_2 = {new Fraction(1, 4), new Fraction(2, 5), new Fraction(1, 2)};
checkArray("compare vect", v_ebeDivide_2.getData(), result_ebeDivide_2);
// octave dot(v1,v2)
Fraction dot = v1.dotProduct(v2);
Assert.assertEquals("compare val ", new Fraction(32), dot);
// octave dot(v1,v2_t)
Fraction dot_2 = v1.dotProduct(v2_t);
Assert.assertEquals("compare val ", new Fraction(32), dot_2);
FieldMatrix<Fraction> m_outerProduct = v1.outerProduct(v2);
Assert.assertEquals("compare val ", new Fraction(4), m_outerProduct.getEntry(0, 0));
FieldMatrix<Fraction> m_outerProduct_2 = v1.outerProduct(v2_t);
Assert.assertEquals("compare val ", new Fraction(4), m_outerProduct_2.getEntry(0, 0));
ArrayFieldVector<Fraction> v_projection = v1.projection(v2);
Fraction[] result_projection = {
new Fraction(128, 77), new Fraction(160, 77), new Fraction(192, 77)
};
checkArray("compare vect", v_projection.getData(), result_projection);
FieldVector<Fraction> v_projection_2 = v1.projection(v2_t);
Fraction[] result_projection_2 = {
new Fraction(128, 77), new Fraction(160, 77), new Fraction(192, 77)
};
checkArray("compare vect", v_projection_2.getData(), result_projection_2);
}
/**
* Convert a {@link FieldMatrix}/{@link BigFraction} matrix to a {@link RealMatrix}.
*
* @param m matrix to convert
* @return converted matrix
*/
public static Array2DRowRealMatrix bigFractionMatrixToRealMatrix(
final FieldMatrix<BigFraction> m) {
final BigFractionMatrixConverter converter = new BigFractionMatrixConverter();
m.walkInOptimizedOrder(converter);
return converter.getConvertedMatrix();
}
