/*
* Copyright 2011-2013, by Vladimir Kostyukov and Contributors.
*
* This file is part of la4j project (http://la4j.org)
*
* Licensed 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.
*
* Contributor(s): Evgenia Krivova
* Jakob Moellers
* Maxim Samoylov
* Anveshi Charuvaka
* Todd Brunhoff
* Catherine da Graca
*
*/
package org.la4j.matrix;
import java.util.ArrayList;
import org.junit.Assert;
import org.junit.Test;
import org.la4j.*;
import org.la4j.vector.DenseVector;
import static org.la4j.M.*;
import static org.la4j.V.*;
public abstract class MatrixTest<T extends Matrix> {
protected MatrixFactory<T> factory;
public MatrixTest(MatrixFactory<T> factory) {
this.factory = factory;
}
public T m(double[]... values) {
return M.m(values).to(factory);
}
public T mz(int rows, int columns) {
return M.mz(rows, columns).to(factory);
}
@Test
public void testInsert_3x3_into_3x3() {
Matrix a = m(a(1.0, 2.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0));
Matrix b = mz(3, 3);
Assert.assertEquals(a, b.insert(a));
}
@Test
public void testInsert_2x2_into_3x3() {
Matrix a = m(a(1.0, 2.0),
a(3.0, 4.0));
Matrix b = mz(3, 3);
Assert.assertEquals(a, b.insert(a).slice(0, 0, 2, 2));
}
@Test
public void testInsert_2x2_into_3x3_partial() {
Matrix a = m(a(1.0, 2.0),
a(3.0, 4.0));
Matrix b = mz(3, 3);
Assert.assertEquals(a.slice(0, 0, 1, 2), b.insert(a, 1, 2).slice(0, 0, 1, 2));
}
@Test
public void testInsert_3x3_slice_into_4x4_offset() {
Matrix a = m(a(1.0, 2.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0));
Matrix b = mz(4, 4);
Assert.assertEquals(a.slice(1, 1, 3, 3), b.insert(a, 1, 1, 1, 1, 2, 2).slice(1, 1, 3, 3));
}
@Test
public void testInsert_2x2_into_4x4_offset() {
Matrix a = m(a(1.0, 2.0),
a(3.0, 4.0));
Matrix b = mz(3, 3);
Assert.assertEquals(a, b.insert(a, 1, 1, a.rows(), a.columns()).slice(1, 1, 3, 3));
}
@Test
public void testInsert_3x1_into_3x3_offset() {
Matrix a = m(a(1.0),
a(2.0),
a(3.0));
Matrix b = mz(3, 3);
Assert.assertEquals(a, b.insert(a, 0, 2, a.rows(), a.columns()).slice(0, 2, 3, 3));
}
@Test
public void testInsert_1x3_into_3x3_offset() {
Matrix a = m(a(1.0, 2.0, 3.0));
Matrix b = mz(3, 3);
Assert.assertEquals(a, b.insert(a, 2, 0, a.rows(), a.columns()).slice(2, 0, 3, 3));
}
@Test
public void testAccess_3x3() {
Matrix a = m(a(1.0, 0.0, 3.0),
a(0.0, 5.0, 0.0),
a(7.0, 0.0, 9.0));
a.set(0, 1, a.get(1, 1) * 2);
Assert.assertEquals(10.0, a.get(0, 1), Matrices.EPS);
}
@Test
public void testGetColumn_4x4() {
Matrix a = m(a(8.0, 3.0, 1.0, 9.0),
a(4.0, 9.0, 6.0, 6.0),
a(9.0, 1.0, 1.0, 4.0),
a(5.0, 7.0, 3.0, 0.0));
Vector b = v(8.0, 4.0, 9.0, 5.0);
Vector c = v(1.0, 6.0, 1.0, 3.0);
Assert.assertEquals(b, a.getColumn(0));
Assert.assertEquals(c, a.getColumn(2));
}
@Test
public void testGetRow_4x4() {
Matrix a = m(a(8.0, 3.0, 1.0, 9.0),
a(4.0, 9.0, 6.0, 6.0),
a(9.0, 1.0, 1.0, 4.0),
a(5.0, 7.0, 3.0, 0.0));
Vector b = v(8.0, 3.0, 1.0, 9.0);
Vector c = v(9.0, 1.0, 1.0, 4.0);
Assert.assertEquals(b, a.getRow(0));
Assert.assertEquals(c, a.getRow(2));
}
@Test
public void testResize_3x3_to_4x4_to_2x2() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix b = m(a(1.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0),
a(0.0, 0.0, 9.0, 0.0),
a(0.0, 0.0, 0.0, 0.0));
Matrix c = m(a(1.0, 0.0),
a(0.0, 5.0));
a = a.copyOfShape(a.rows() + 1, a.columns() + 1);
Assert.assertEquals(b, a);
a = a.copyOfShape(a.rows() - 2, a.columns() - 2);
Assert.assertEquals(c, a);
}
@Test
public void testResize_2x3_to_3x4_to_1x2() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0));
Matrix b = m(a(1.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0),
a(0.0, 0.0, 0.0, 0.0));
Matrix c = m(a(1.0, 0.0));
a = a.copyOfShape(a.rows() + 1, a.columns() + 1);
Assert.assertEquals(b, a);
a = a.copyOfShape(a.rows() - 2, a.columns() - 2);
Assert.assertEquals(c, a);
}
@Test
public void testResize_2x3_to_2x4_to_2x1() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0));
Matrix b = m(a(1.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0));
Matrix c = m(a(1.0),
a(0.0));
a = a.copyOfShape(a.rows(), a.columns() + 1);
Assert.assertEquals(b, a);
a = a.copyOfShape(a.rows(), a.columns() - 3);
Assert.assertEquals(c, a);
}
@Test
public void testResize_3x5_to_4x5_to_2x5() {
Matrix a = m(a(1.0, 0.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0, 0.0),
a(0.0, 0.0, 7.0, 0.0, 0.0));
Matrix b = m(a(1.0, 0.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0, 0.0),
a(0.0, 0.0, 7.0, 0.0, 0.0),
a(0.0, 0.0, 0.0, 0.0, 0.0));
Matrix c = m(a(1.0, 0.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0, 0.0));
a = a.copyOfShape(a.rows() + 1, a.columns());
Assert.assertEquals(b, a);
a = a.copyOfShape(a.rows() - 2, a.columns());
Assert.assertEquals(c, a);
}
@Test
public void testSlice_4x4_to_2x2() {
Matrix a = m(a(1.0, 0.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 0.0),
a(0.0, 0.0, 9.0, 0.0),
a(0.0, 0.0, 0.0, 15.0));
Matrix b = m(a(5.0, 0.0),
a(0.0, 9.0));
Assert.assertEquals(b, a.slice(1, 1, 3, 3));
}
@Test
public void testSlice_3x4_to_1x4() {
Matrix a = m(a(1.0, 0.0, 3.0, 0.0),
a(0.0, 5.0, 0.0, 7.0),
a(4.0, 0.0, 9.0, 0.0));
Matrix b = m(a(4.0, 0.0, 9.0, 0.0));
Assert.assertEquals(b, a.slice(2, 0, 3, 4));
}
@Test
public void testSwap_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix b = m(a(0.0, 0.0, 9.0),
a(0.0, 5.0, 0.0),
a(1.0, 0.0, 0.0));
Matrix c = m(a(9.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 1.0));
a.swapRows(0, 2);
Assert.assertEquals(b, a);
b.swapColumns(0, 2);
Assert.assertEquals(c, b);
}
@Test
public void testSwap_2x4() {
Matrix a = m(a(1.0, 0.0, 0.0, 3.0),
a(0.0, 5.0, 4.0, 0.0));
Matrix b = m(a(0.0, 5.0, 4.0, 0.0),
a(1.0, 0.0, 0.0, 3.0));
Matrix c = m(a(0.0, 4.0, 5.0, 0.0),
a(1.0, 0.0, 0.0, 3.0));
a.swapRows(0, 1);
Assert.assertEquals(b, a);
b.swapColumns(1, 2);
Assert.assertEquals(c, b);
}
@Test
public void testSwap_5x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 4.0),
a(7.0, 0.0, 2.0),
a(0.0, 8.0, 0.0),
a(5.0, 0.0, 6.0));
Matrix b = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 4.0),
a(0.0, 8.0, 0.0),
a(7.0, 0.0, 2.0),
a(5.0, 0.0, 6.0));
Matrix c = m(a(1.0, 0.0, 0.0),
a(0.0, 4.0, 5.0),
a(0.0, 0.0, 8.0),
a(7.0, 2.0, 0.0),
a(5.0, 6.0, 0.0));
a.swapRows(2, 3);
Assert.assertEquals(b, a);
b.swapColumns(1, 2);
Assert.assertEquals(c, b);
}
@Test
public void testTranspose_4x4() {
Matrix a = m(a(0.0, 14.2, 0.0, 4.0),
a(0.0, 5.0, 10.0, 0.0),
a(0.0, 3.0, 0.0, 2.3),
a(11.0, 7.0, 0.0, 1.0));
Matrix b = m(a(0.0, 0.0, 0.0, 11.0),
a(14.2, 5.0, 3.0, 7.0),
a(0.0, 10.0, 0.0, 0.0),
a(4.0, 0.0, 2.3, 1.0));
Matrix c = a.transpose();
Assert.assertEquals(b, c);
Matrix d = c.transpose();
Assert.assertEquals(a, d);
}
@Test
public void testTranspose_5x3() {
Matrix a = m(a(0.0, 14.2, 0.0),
a(0.0, 5.0, 10.0),
a(0.0, 3.0, 0.0),
a(11.0, 7.0, 0.0),
a(12.0, 7.5, 0.0));
Matrix b = m(a(0.0, 0.0, 0.0, 11.0, 12.0),
a(14.2, 5.0, 3.0, 7.0, 7.5),
a(0.0, 10.0, 0.0, 0.0, 0));
Matrix c = a.transpose();
Assert.assertEquals(b, c);
Matrix d = c.transpose();
Assert.assertEquals(a, d);
}
@Test
public void testTranspose_6x5() {
Matrix a = m(a(8.93, 3.96, 7.37, 3.43, 7.05),
a(5.88, 8.26, 5.79, 9.08, 7.75),
a(6.57, 2.51, 8.8, 1.16, 8.11),
a(9.3, 9.61, 0.87, 2.3, 2.93),
a(3.65, 4.63, 7.83, 3.66, 9.04),
a(0.08, 6.12, 6.15, 4.93, 6.72));
Matrix b = m(a(8.93, 5.88, 6.57, 9.3, 3.65, 0.08),
a(3.96, 8.26, 2.51, 9.61, 4.63, 6.12),
a(7.37, 5.79, 8.8, 0.87, 7.83, 6.15),
a(3.43, 9.08, 1.16, 2.3, 3.66, 4.93),
a(7.05, 7.75, 8.11, 2.93, 9.04, 6.72));
Matrix c = a.transpose();
Assert.assertEquals(b, c);
Matrix d = c.transpose();
Assert.assertEquals(a, d);
}
@Test
public void testAdd_3x3() {
for (Matrix b: ms(a(11.0, 10.0, 10.0),
a(10.0, 15.0, 10.0),
a(10.0, 10.0, 19.0))) {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix c = m(a(12.0, 10.0, 10.0),
a(10.0, 20.0, 10.0),
a(10.0, 10.0, 28.0));
Assert.assertEquals(b, a.add(10.0));
Assert.assertEquals(c, a.add(b));
}
}
@Test
public void testAdd_4x2() {
for (Matrix b: ms(a(11.0, 10.0),
a(10.0, 15.0),
a(17.0, 10.0),
a(10.0, 19.0))) {
Matrix a = m(a(1.0, 0.0),
a(0.0, 5.0),
a(7.0, 0.0),
a(0.0, 9.0));
Matrix c = m(a(12.0, 10.0),
a(10.0, 20.0),
a(24.0, 10.0),
a(10.0, 28.0));
Assert.assertEquals(b, a.add(10.0));
Assert.assertEquals(c, a.add(b));
}
}
@Test
public void testSubtract_3x3() {
for (Matrix b: ms(a(-9.0, -10.0, -10.0),
a(-10.0, -5.0, -10.0),
a(-10.0, -10.0, -1.0))) {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix c = m(a(10.0, 10.0, 10.0),
a(10.0, 10.0, 10.0),
a(10.0, 10.0, 10.0));
Assert.assertEquals(b, a.subtract(10.0));
Assert.assertEquals(c, a.subtract(b));
}
}
@Test
public void testSubtract_2x4() {
for (Matrix b: ms(a(-9.0, -10.0, -3.0, -10.0),
a(-10.0, -5.0, -10.0, -1.0))) {
Matrix a = m(a(1.0, 0.0, 7.0, 0.0),
a(0.0, 5.0, 0.0, 9.0));
Matrix c = m(a(10.0, 10.0, 10.0, 10.0),
a(10.0, 10.0, 10.0, 10.0));
Assert.assertEquals(b, a.subtract(10.0));
Assert.assertEquals(c, a.subtract(b));
}
}
@Test
public void testMultiply_2x3() {
Matrix a = m(a(1.0, 0.0, 3.0),
a(0.0, 5.0, 0.0));
Matrix b = m(a(2.0, 0.0, 6.0),
a(0.0, 10.0, 0.0));
Assert.assertEquals(b, a.multiply(2.0));
}
@Test
public void testMultiply_2x3_3() {
for (Vector b: vs(10.0, 0.0, 30.0)) {
Matrix a = m(a(1.0, 0.0, 3.0),
a(0.0, 5.0, 0.0));
Vector c = v(100.0, 0.0);
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_5x2_2() {
for (Vector b: vs(0.0, 10.0)) {
Matrix a = m(a(1.0, 0.0),
a(0.0, 5.0),
a(7.0, 0.0),
a(3.0, 0.0),
a(0.0, 1.0));
Vector c = v(0.0, 50.0, 0.0, 0.0, 10.0);
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_1x1_1x1() {
for (Matrix b: ms(a(8.48))) {
Matrix a = m(a(3.37));
Matrix c = m(a(28.5776));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_2x2_2x2() {
for (Matrix b: ms(a(3.85, 8.28),
a(8.02, 8.39))) {
Matrix a = m(a(2.46, 1.68),
a(7.57, 2.47));
Matrix c = m(a(22.9446, 34.464),
a(48.9539, 83.4029));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_4x4_4x4() {
for (Matrix b: ms(a(4.0, 9.0, 0.0, 3.0),
a(6.0, 7.0, 7.0, 6.0),
a(9.0, 4.0, 3.0, 3.0),
a(4.0, 4.0, 1.0, 6.0))) {
Matrix a = m(a(8.0, 3.0, 1.0, 9.0),
a(4.0, 9.0, 6.0, 6.0),
a(9.0, 1.0, 1.0, 4.0),
a(5.0, 7.0, 3.0, 0.0));
Matrix c = m(a(95.0, 133.0, 33.0, 99.0),
a(148.0, 147.0, 87.0, 120.0),
a(67.0, 108.0, 14.0, 60.0),
a(89.0, 106.0, 58.0, 66.0));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_4x1_1x4() {
for (Matrix b: ms(a(5.19, 6.06, 6.12, 5.92))) {
Matrix a = m(a(6.31),
a(6.06),
a(4.94),
a(9.62));
Matrix c = m(a(32.7489, 38.2386, 38.6172, 37.3552),
a(31.4514, 36.7236, 37.0872, 35.8752),
a(25.6386, 29.9364, 30.2328, 29.2448),
a(49.9278, 58.2972, 58.8744, 56.9504));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_1x10_10x1() {
for (Matrix b: ms(a(9.81),
a(0.14),
a(8.91),
a(8.54),
a(0.97),
a(2.55),
a(1.11),
a(2.52),
a(7.71),
a(1.69))) {
Matrix a = m(a(0.28, 1.61, 5.11, 1.71, 2.21, 5.97, 2.61, 2.58, 0.07, 3.78));
Matrix c = m(a(96.7995));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_3x2_2x3() {
for (Matrix b: ms(a(0.0, 3.0, 0.0),
a(2.0, 0.0, 4.0))) {
Matrix a = m(a(1.0, 9.0),
a(9.0, 1.0),
a(8.0, 9.0));
Matrix c = m(a(18.0, 3.0, 36.0),
a(2.0, 27.0, 4.0),
a(18.0, 24.0, 36.0));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiply_4x9_9x4() {
for (Matrix b: ms(a(9.28, 7.63, 4.1, 4.71),
a(4.68, 2.82, 9.18, 5.39),
a(4.54, 6.86, 1.29, 5.4),
a(8.72, 2.06, 4.28, 7.37),
a(2.43, 3.7, 7.52, 5.87),
a(8.21, 9.36, 4.85, 0.3),
a(9.87, 8.19, 5.03, 6.14),
a(9.47, 4.28, 3.86, 3.12),
a(5.29, 4.41, 5.23, 4.85))) {
Matrix a = m(a(5.98, 3.76, 9.01, 9.68, 2.12, 6.34, 0.64, 6.22, 1.16),
a(8.4, 9.65, 7.06, 2.56, 7.66, 4.69, 3.29, 8.6, 8.55),
a(4.99, 7.06, 6.07, 7.53, 0.08, 1.08, 9.69, 8.51, 6.61),
a(4.72, 7.06, 4.0, 0.75, 2.45, 4.4, 8.33, 5.81, 0.57));
Matrix c = m(a(326.9658, 242.1452, 192.0747, 211.7362),
a(393.7521, 318.7092, 317.9021, 283.44),
a(392.8255, 270.4737, 247.3277, 268.7303),
a(283.873, 230.76, 199.6044, 175.1515));
Assert.assertEquals(c, a.multiply(b));
}
}
@Test
public void testMultiplyByItsTranspose_2x2() {
Matrix a = m(a(1.0, 2.0),
a(0.0, 1.0));
Matrix b = m(a(5.0, 2.0),
a(2.0, 1.0));
Assert.assertEquals(a.multiplyByItsTranspose(), b);
}
@Test
public void testMultiplyByItsTranspose_4x4() {
Matrix a = m(a(3.0, 6.0, 7.0, 11.0),
a(5.0, 2.0, 4.0, 7.0),
a(1.0, -6.0, 2.0, 9.0),
a(10.0, -3.0, -7.0, 9.0));
Matrix b = m(a(215.0, 132.0, 80.0, 62.0),
a(132.0, 94.0, 64.0, 79.0),
a(80.0, 64.0, 122.0, 95.0),
a(62.0, 79.0, 95.0, 239.0));
Assert.assertEquals(a.multiplyByItsTranspose(), b);
}
@Test
public void testMultiplyByItsTranspose_2x3() {
Matrix a = m(a(1.0, 2.0, 3.0),
a(0.0, 1.0, 2.0));
Assert.assertEquals(a.multiplyByItsTranspose(), a.multiply(a.transpose()));
}
@Test
public void testMultiplyByItsTranspose_5x3() {
Matrix a = m(a(0.0, 2.0, 0.0),
a(0.0, 1.0, 2.0),
a(4.0, 0.0, 0.0),
a(0.0, 5.0, 7.0),
a(1.0, 1.0, 0.0));
Assert.assertEquals(a.multiplyByItsTranspose(), a.multiply(a.transpose()));
}
@Test
public void testDivide_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix b = m(a(0.1, 0.0, 0.0),
a(0.0, 0.5, 0.0),
a(0.0, 0.0, 0.9));
Assert.assertEquals(b, a.divide(10.0));
}
@Test
public void testKronecker_3x3_2x2() {
for (Matrix b: ms(a(10.0, 0.0),
a(0.0, 20.0))) {
Matrix a = m(a(1.0, 0.0, 3.0),
a(0.0, 5.0, 0.0));
Matrix c = m(a(10.0, 0.0, 0.0, 0.0, 30.0, 0.0),
a(0.0, 20.0, 0.0, 0.0, 0.0, 60.0),
a(0.0, 0.0, 50.0, 0.0, 0.0, 0.0),
a(00.0, 0.0, 0.0, 100.0, 0.0, 0.0));
Assert.assertEquals(c, a.kroneckerProduct(b));
}
}
@Test
public void testTrace_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Assert.assertTrue(Math.abs(a.trace() - 15.0) < Matrices.EPS);
}
@Test
public void testDiagonalProduct_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Assert.assertTrue(Math.abs(a.diagonalProduct() - 45.0) < Matrices.EPS);
}
@Test
public void testProduct_3x3() {
Matrix a = m(a(1.0, 1.0, 1.0),
a(1.0, 5.0, 1.0),
a(1.0, 1.0, 9.0));
Assert.assertTrue(Math.abs(a.product() - 45.0) < Matrices.EPS);
}
@Test
public void testSum_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Assert.assertTrue(Math.abs(a.sum() - 15.0) < Matrices.EPS);
}
@Test
public void testHadamardProduct_3x3() {
for (Matrix b: ms(a(9.0, 8.0, 7.0),
a(6.0, 5.0, 4.0),
a(3.0, 2.0, 1.0))) {
Matrix a = m(a(1.0, 2.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0));
Matrix c = m(a(9.0, 16.0, 21.0),
a(24.0, 25.0, 24.0),
a(21.0, 16.0, 9.0));
Assert.assertEquals(c, a.hadamardProduct(b));
}
}
@Test
public void testHadamardProduct_5x2() {
for (Matrix b: ms(a(6.0, 5.0),
a(5.0, 4.0),
a(4.0, 3.0),
a(3.0, 2.0),
a(2.0, 1.0))) {
Matrix a = m(a(1.0, 2.0),
a(2.0, 3.0),
a(3.0, 4.0),
a(4.0, 5.0),
a(5.0, 6.0));
Matrix c = m(a(6.0, 10.0),
a(10.0, 12.0),
a(12.0, 12.0),
a(12.0, 10.0),
a(10.0, 6.0));
Assert.assertEquals(c, a.hadamardProduct(b));
}
}
@Test
public void testHadamardProduct_3x4() {
for (Matrix b: ms(a(6.0, 5.0, 4.0, 3.0),
a(5.0, 4.0, 3.0, 2.0),
a(4.0, 3.0, 2.0, 1.0))) {
Matrix a = m(a(1.0, 2.0, 3.0, 4.0),
a(2.0, 3.0, 4.0, 5.0),
a(3.0, 4.0, 5.0, 6.0));
Matrix c = m(a(6.0, 10.0, 12.0, 12.0),
a(10.0, 12.0, 12.0, 10.0),
a(12.0, 12.0, 10.0, 6.0));
Assert.assertEquals(c, a.hadamardProduct(b));
}
}
@Test
public void testHadamardProduct_1x3() {
for (Matrix b: ms(a(6.0, 5.0, 4.0, 3.0))) {
Matrix a = m(a(1.0, 2.0, 3.0, 4.0));
Matrix c = m(a(6.0, 10.0, 12.0, 12.0));
Assert.assertEquals(c, a.hadamardProduct(b));
}
}
@Test
public void testDeterminant_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Assert.assertEquals(45.0, a.determinant(), 1e-5);
}
@Test
public void testDeterminant_4x4() {
Matrix a = m(a(3.0, 3.0, 4.0, 43.0),
a(5.0, 5.0, 6.0, 6.0),
a(70.0, 7.0, 8.0, 8.0),
a(9.0, 9.0, 10.0, 11.0));
Assert.assertEquals(-9954.0, a.determinant(), 1e-5);
}
@Test
public void testDeterminant_4x4_2() {
Matrix a = m(a(1.0, 2.0, 3.0, 4.0),
a(1.0, 1.0, 1.0, 1.0),
a(2.0, 3.0, 4.0, 5.0),
a(2.0, 2.0, 2.0, 2.0));
Assert.assertEquals(0.0, a.determinant(), 1e-5);
}
@Test
public void testDeterminant_7x7() {
Matrix a = m(a(1.0, 6.0, -8.0, 5.0, -3.0, 41.0, -2.0),
a(-8.0, -5.0, 7.0, 23.0, -7.0, 12.0, -2.0),
a(8.0, 77.0, -65.0, 13.0, -8.0, 55.0, -47.0),
a(26.0, 27.0, -81.0, -1.0, 10.0, -48.0, -3.0),
a(0.0, 34.0, -79.0, 4.0, -1.0, 28.0, 6.0),
a(-5.0, 8.0, -20.0, 36.0, -12.0, -7.0, -10.0),
a(-6.0, 13.0, 9.0, -4.0, 95.0, 2.0, 46.0));
Assert.assertEquals(-9134649369.0, a.determinant(), 1e-5);
}
@Test
public void testDeterminant_6x6() {
Matrix a = m(a(5.0, 89.0, 6.0, 23.0, 6.0, 4.0),
a(4.0, 0.0, 27.0, 90.0, 42.0, 12.0),
a(6.0, 0.0, 24.0, 9.0, 41.0, 15.0),
a(31.0, 0.0, 3.0, 22.0, 2.0, 1.0),
a(2.0, 0.0, 37.0, 4.0, 0.0, 21.0),
a(23.0, 8.0, 7.0, 0.0, 12.0, 10.0));
Assert.assertEquals(-1695428964.0, a.determinant(), 1e-5);
}
@Test
public void testDeterminant_5x5() {
Matrix a = m(a(-10.0, 89.0, -6.0, 23.0, 6.0, 4.0),
a(4.0, 5.0, 27.0, 90.0, 0.0, 12.0),
a(6.0, 0.0, 0.0, 9.0, 1.0, 15.0),
a(31.0, 11.0, 0.0, 12.0, 2.0, 1.0),
a(2.0, 0.0, 5.0, 4.0, -1.0, -21.0),
a(3.0, -18.0, 7.0, 0.0, 12.0, 10.0));
Assert.assertEquals(3180462.0, a.determinant(), 1e-5);
}
@Test
public void testRank_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Assert.assertEquals(3, a.rank());
}
@Test
public void testRank_4x4() {
Matrix a = m(a(1.0, 0.0, 0.0, 3.5),
a(0.0, 0.0, 0.0, 2.0),
a(0.0, 0.0, 9.0, 0.0),
a(1.0, 0.0, 0.0, 0.0));
Assert.assertEquals(3, a.rank());
}
@Test
public void testRank_4x4_2() {
Matrix a = m(a(1.0, 2.0, 3.0, 4.0),
a(1.0, 1.0, 1.0, 1.0),
a(2.0, 3.0, 4.0, 5.0),
a(2.0, 2.0, 2.0, 2.0));
Assert.assertEquals(2, a.rank());
}
@Test
public void testRank_2x4() {
Matrix a = m(a(1.0, 0.0, 0.0, 3.5),
a(0.0, 1.3, 0.0, 2.0));
Assert.assertEquals(2, a.rank());
}
@Test
public void testRank_5x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 0.0, 0.0),
a(1.0, 0.0, 9.0),
a(1.0, 0.0, 0.0),
a(1.0, 0.0, 0.0));
Assert.assertEquals(2, a.rank());
}
@Test
public void testRank_10x10() {
Matrix a = m(a(15, 6, 84, 67, 4, 11, 81, 47, 57, 41),
a(21, 94, 86, 55, 16, 31, 60, 62, 33, 61),
a(3, 32, 57, 56, 55, 66, 70, 87, 6, 37),
a(71, 48, 8, 24, 43, 61, 56, 24, 37, 63),
a(79, 45, 36, 20, 13, 96, 31, 77, 67, 54),
a(20, 63, 41, 79, 46, 100, 90, 23, 42, 94),
a(15, 10, 36, 18, 25, 81, 76, 29, 23, 53),
a(43, 79, 60, 94, 26, 24, 50, 38, 53, 12),
a(100, 59, 26, 99, 72, 17, 29, 3, 76, 14),
a(18, 38, 141, 123, 59, 77, 151, 134, 63, 78));
Assert.assertEquals(9, a.rank());
}
@Test
public void testRank_3x6() {
Matrix a = m(a(5.0, 7.0, 10.0, 3.0, 5.0, 8.0),
a(5.0, 2.0, 3.0, 10.0, 11.0, 9.0),
a(4.0, 3.0, 9.0, 12.0, 8.0, 9.0));
Assert.assertEquals(3, a.rank());
}
@Test
public void testRank_7x11() {
Matrix a = m(a(0.0, 13.0, 25.0, 43.0, 81.0, 0.0, 39.0, 60.0, 70.0, 21.0, 44.0, 0.0),
a(44.0, 0.0, 13.0, 67.0, 35.0, 0.0, 84.0, 35.0, 23.0, 88.0, 11.0, 0.0),
a(5.0, 34.0, 0.0, 143.0, 35.0, 0.0, 65.0, 99.0, 22.0, 13.0, 26.0, 0.0),
a(89.0, 23.0, 13.0, 0.0, 78.0, 0.0, 13.0, 24.0, 98.0, 65.0, 0.0, 0.0),
a(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
a(56.0, 4.0, 24.0, 56.0, 78.0, 0.0, 13.0, 0.0, 24.0, 57.0, 8.0, 1.0),
a(0.0, 0.0, 46.0, 666.0, 34.0, 13.0, 67.0, 9.0, 12.0, 45.0, 38.0, 0.0));
Assert.assertEquals(6, a.rank());
}
@Test
public void testRank_1x4() {
Matrix a = m(a(0.0, 1.0, 0.0, 0.0));
Assert.assertEquals(1, a.rank());
}
@Test
public void testRank_3x3_empty() {
Matrix a = mz(3, 3);
Assert.assertEquals(0, a.rank());
}
@Test
public void testRank_0x0() {
Matrix a = mz(0, 0);
Assert.assertEquals(0, a.rank());
}
@Test
public void testRank_7x3() {
Matrix a = m(a(1, 2, 0),
a(0, 0, 0),
a(0, 0, 0),
a(0, 0, 0),
a(0, 0, 1),
a(0, 0, -1),
a(1, 2, 1));
Assert.assertEquals(2, a.rank());
}
@Test
public void testRank_3x1() {
Matrix a = m(a(1),
a(2),
a(0));
Assert.assertEquals(1, a.rank());
}
@Test
public void testRowAccess_2x1() {
Matrix a = m(a(99.0),
a(88.0));
Matrix b = m(a(99.0),
a(99.0));
a.setRow(1, a.getRow(0));
Assert.assertEquals(b, a);
}
@Test
public void testRowAccess_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix b = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(1.0, 0.0, 0.0));
a.setRow(2, a.getRow(0));
Assert.assertEquals(b, a);
}
@Test
public void testRowAccess_2x4() {
Matrix a = m(a(1.0, 0.0, 4.0, 0.0),
a(0.0, 5.0, 0.0, 7.0));
Matrix b = m(a(1.0, 0.0, 4.0, 0.0),
a(1.0, 0.0, 4.0, 0.0));
a.setRow(1, a.getRow(0));
Assert.assertEquals(b, a);
}
@Test
public void testRowAccess_5x3() {
Matrix a = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0),
a(0.0, 1.0, 8.0),
a(2.0, 0.0, 0.0));
Matrix b = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0),
a(9.0, 0.0, 0.0),
a(2.0, 0.0, 0.0));
a.setRow(3, a.getRow(2));
Assert.assertEquals(b, a);
}
@Test
public void testRowAccess_6x4() {
Matrix a = m(a(0.0, 18.0, 15.0, 0.0),
a(1.0, 0.0, -55.0, 9.0),
a(0.0, 0.0, 71.0, 19.0),
a(-1.0, -8.0, 54.0, 0.0),
a(25.0, 18.0, 0.0, 0.0),
a(78.0, 28.0, 0.0, -8.0));
Matrix b = m(a(0.0, 18.0, 15.0, 0.0),
a(1.0, 0.0, -55.0, 9.0),
a(0.0, 0.0, 71.0, 19.0),
a(-1.0, -8.0, 54.0, 0.0),
a(25.0, 18.0, 0.0, 0.0),
a(25.0, 18.0, 0.0, 0.0));
a.setRow(5, a.getRow(4));
Assert.assertEquals(b, a);
}
@Test
public void testInsertRow_2x3() {
Matrix a = m(a(1.0, 0.0, 4.0),
a(9.0, 0.0, 0.0));
Vector row = v(a(0.0, 5.0, 3.0));
Matrix b = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0));
Assert.assertEquals(b, a.insertRow(1, row));
}
@Test
public void testInsertColumn_3x2() {
Matrix a = m(a(1.0, 4.0),
a(0.0, 3.0),
a(9.0, 0.0));
Vector column = v(a(0.0, 5.0, 0.0));
Matrix b = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0));
Assert.assertEquals(b, a.insertColumn(1, column));
}
@Test
public void testRemoveRow_3x3() {
Matrix a = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0));
Matrix b = m(a(1.0, 0.0, 4.0),
a(9.0, 0.0, 0.0));
Assert.assertEquals(b, a.removeRow(1));
}
@Test
public void testRemoveColumn_3x3() {
Matrix a = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0));
Matrix b = m(a(1.0, 4.0),
a(0.0, 3.0),
a(9.0, 0.0));
Assert.assertEquals(b, a.removeColumn(1));
}
@Test(expected = IndexOutOfBoundsException.class)
public void testRemoveRow_3x3_Exception() {
Matrix a = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0));
a.removeRow(3);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testRemoveColumn_3x3_Exception() {
Matrix a = m(a(1.0, 0.0, 4.0),
a(0.0, 5.0, 3.0),
a(9.0, 0.0, 0.0));
a.removeColumn(3);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testRemoveRow_empty() {
Matrix a = mz(0, 0);
a.removeFirstRow();
}
/**
* Returns true if both matrices contain the same elements and have equal
* dimensions.
*
* @param matrix1 Matrix 1
* @param matrix2 Matrix 2
* @return True if both matrices contain the same elements and have equal
* dimensions.
*/
public boolean testWhetherMatricesContainSameElements(Matrix matrix1,
Matrix matrix2) {
// Test for equal columns and rows
if (matrix1.rows() != matrix2.rows()) {
return false;
}
if (matrix1.columns() != matrix2.columns()) {
return false;
}
// Test for same elements
double[] a = new double[matrix1.columns() * matrix1.rows()];
int k = 0;
for (int i = 0; i < matrix1.rows(); i++) {
for (int j = 0; j < matrix1.columns(); j++) {
a[k] = matrix1.get(i, j);
k++;
}
}
ArrayList<Double> b = new ArrayList<Double>();
for (int i = 0; i < matrix2.rows(); i++) {
for (int j = 0; j < matrix2.columns(); j++) {
b.add(matrix2.get(i, j));
}
}
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < b.size(); j++) {
if (a[i] == b.get(j)) {
b.remove(j); // If match found, remove it from ArrayList to
// decrease complexity
break;
}
}
}
return b.size() == 0;
}
@Test
public void testTestWhetherMatricesContainSameElements() {
Matrix a = m(a(1.0, 1.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0));
Matrix b = m(a(1.0, 1.0, 4.0),
a(5.0, 6.0, 9.0),
a(7.0, 3.0, 8.0));
Assert.assertTrue(testWhetherMatricesContainSameElements(b, a));
Matrix c = m(a(1.0, 1.0, 3.0),
a(4.0, 52.0, 6.0),
a(7.0, 8.0, 9.0));
Assert.assertFalse(testWhetherMatricesContainSameElements(c, a));
}
@Test
public void testShuffle_3x2() {
Matrix a = m(a(1.0, 2.0),
a(4.0, 5.0),
a(7.0, 8.0));
Matrix b = a.shuffle();
Assert.assertTrue(testWhetherMatricesContainSameElements(b, a));
}
@Test
public void testShuffle_5x3() {
Matrix a = m(a(1.0, 2.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0),
a(10.0, 11.0, 12.0),
a(13.0, 14.0, 15.0));
Matrix b = a.shuffle();
Assert.assertTrue(testWhetherMatricesContainSameElements(b, a));
}
@Test
public void testRotate_3x1() {
Matrix a = m(a(1.0),
a(3.0),
a(5.0));
Matrix b = m(a(5.0, 3.0, 1.0));
Assert.assertEquals(b, a.rotate());
}
@Test
public void testRotate_2x2() {
Matrix a = m(a(1.0, 2.0),
a(3.0, 4.0));
Matrix b = m(a(3.0, 1.0),
a(4.0, 2.0));
Assert.assertEquals(b, a.rotate());
}
@Test
public void testRotate_2x4() {
Matrix a = m(a(1.0, 2.0, 3.0, 4.0),
a(5.0, 6.0, 7.0, 8.0));
Matrix b = m(a(5.0, 1.0),
a(6.0, 2.0),
a(7.0, 3.0),
a(8.0, 4.0));
Assert.assertEquals(b, a.rotate());
}
@Test
public void testRotate_5x3() {
Matrix a = m(a(1.0, 2.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0),
a(10.0, 11.0, 12.0),
a(13.0, 14.0, 15.0));
Matrix b = m(a(13.0, 10.0, 7.0, 4.0, 1.0),
a(14.0, 11.0, 8.0, 5.0, 2.0),
a(15.0, 12.0, 9.0, 6.0, 3.0));
Assert.assertEquals(b, a.rotate());
}
@Test
public void testColumnAccess_2x1() {
Matrix a = m(a(11.0, 22.0));
Matrix b = m(a(22.0, 22.0));
a.setColumn(0, a.getColumn(1));
Assert.assertEquals(b, a);
}
@Test
public void testColumnAccess_3x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 9.0));
Matrix b = m(a(1.0, 0.0, 1.0),
a(0.0, 5.0, 0.0),
a(0.0, 0.0, 0.0));
a.setColumn(2, a.getColumn(0));
Assert.assertEquals(b, a);
}
@Test
public void testColumnAccess_2x4() {
Matrix a = m(a(1.0, 0.0, 0.0, 4.0),
a(0.0, 5.0, 0.0, 9.0));
Matrix b = m(a(1.0, 0.0, 0.0, 1.0),
a(0.0, 5.0, 0.0, 0.0));
a.setColumn(3, a.getColumn(0));
Assert.assertEquals(b, a);
}
@Test
public void testColumnAccess_5x3() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 5.0, 6.0),
a(3.0, 0.0, 4.0),
a(0.0, 0.0, 0.0),
a(2.0, 7.0, 0.0));
Matrix b = m(a(1.0, 1.0, 0.0),
a(0.0, 0.0, 6.0),
a(3.0, 3.0, 4.0),
a(0.0, 0.0, 0.0),
a(2.0, 2.0, 0.0));
a.setColumn(1, a.getColumn(0));
Assert.assertEquals(b, a);
}
@Test
public void testColumnAccess_6x4() {
Matrix a = m(a(0.0, 18.0, 15.0, 0.0),
a(1.0, 0.0, -55.0, 9.0),
a(0.0, 0.0, 71.0, 19.0),
a(-1.0, -8.0, 54.0, 0.0),
a(25.0, 18.0, 0.0, 0.0),
a(78.0, 28.0, 0.0, -8.0));
Matrix b = m(a(0.0, 18.0, 15.0, 0.0),
a(1.0, 0.0, -55.0, 1.0),
a(0.0, 0.0, 71.0, 0.0),
a(-1.0, -8.0, 54.0, -1.0),
a(25.0, 18.0, 0.0, 25.0),
a(78.0, 28.0, 0.0, 78.0));
a.setColumn(3, a.getColumn(0));
Assert.assertEquals(b, a);
}
@Test
public void testCopy_3x3() {
Matrix a = m(a(1.0, 2.0, 3.0),
a(4.0, 5.0, 6.0),
a(7.0, 8.0, 9.0));
Assert.assertEquals(a, a.copy());
}
@Test
public void testBlank_3x3() {
Matrix a = m(a(0.0, 0.0, 3.0),
a(0.0, 0.0, 6.0),
a(0.0, 0.0, 9.0));
Matrix b = m(a(0.0, 0.0, 0.0),
a(0.0, 0.0, 0.0),
a(0.0, 0.0, 0.0));
Assert.assertEquals(b, a.blank());
}
@Test
public void testNormalize_EuclideanNormAccumulator() {
Matrix a = m(a(0.0, 3.0), a(4.0, 0.0));
Assert.assertEquals(5.0, a.euclideanNorm(), Matrices.EPS);
}
@Test
public void testNormalize_ManhattanNormAccumulator() {
Matrix a = m(a(0.0, 3.0), a(4.0, 0.0));
Assert.assertEquals(7.0, a.manhattanNorm(), Matrices.EPS);
}
@Test
public void testNormalize_InfinityNormAccumulator() {
Matrix a = m(a(0.0, 3.0), a(4.0, 0.0));
Assert.assertEquals(4.0, a.infinityNorm(), Matrices.EPS);
}
@Test
public void testPower_2x2() {
Matrix a = m(a(1.0, 2.0),
a(3.0, 4.0));
Matrix b = m(a(7.0, 10.0),
a(15.0, 22.0));
Matrix c = a.power(2);
Assert.assertEquals(b, c);
Matrix d = m(a(37.0, 54.0),
a(81.0, 118.0));
Matrix e = a.power(3);
Assert.assertEquals(d, e);
Matrix f = m(a(5743.0, 8370.0),
a(12555.0, 18298.0));
Matrix g = a.power(6);
Assert.assertEquals(f, g);
}
@Test
public void testPower_3x3() {
Matrix h = m(a(1.0, 0.0, 0.0),
a(4.0, 3.0, 6.0),
a(0.0, 0.0, 9.0));
Matrix i = m(a(1.0, 0.0, 0.0),
a(160.0, 81.0, 6480.0),
a(0.0, 0.0, 6561.0));
Matrix j = h.power(4);
Assert.assertEquals(i, j);
Matrix k = h.power(1);
Assert.assertEquals(h, k);
}
@Test
public void testMax() {
Matrix a = m(a(0, 0, -1),
a(0, -3, 0),
a(6, -7, -2));
Assert.assertEquals(6.0, a.max(), Matrices.EPS);
}
@Test
public void testMaxCompressed() {
Matrix a = m(a(0, 0, -1),
a(0, -3, 0),
a(0, -7, -2));
Assert.assertEquals(0.0, a.max(), Matrices.EPS);
}
@Test
public void testMinCompressed() {
Matrix a = m(a(0, 0, 1),
a(0, 3, 0),
a(0, 7, 2));
Assert.assertEquals(0.0, a.min(), Matrices.EPS);
}
@Test
public void testMin() {
Matrix a = m(a(0, 0, -1),
a(0, -3, 0),
a(0, -7, -2));
Assert.assertEquals(-7.0, a.min(), Matrices.EPS);
}
@Test
public void testMaxInRow() {
Matrix a = m(a(0, 0, 1, 0),
a(-3, 2, 0, 1),
a(-2, 0, 0, -1));
Assert.assertEquals(0.0, a.maxInRow(2), Vectors.EPS);
}
@Test
public void testMinInRow() {
Matrix a = m(a(0, 0, 1, 0),
a(-3, 2, 0, 1),
a(2, 0, 0, 1));
Assert.assertEquals(0.0, a.minInRow(2), Vectors.EPS);
}
@Test
public void testMaxInColumn() {
Matrix a = m(a(0, 0, 1, 0),
a(-3, 2, 0, 1),
a(-2, 0, 0, -1));
Assert.assertEquals(0.0, a.maxInColumn(0), Vectors.EPS);
}
@Test
public void testMinInColumn() {
Matrix a = m(a(0, 0, 1, 0),
a(-3, 2, 0, 1),
a(-2, 0, 0, -1));
Assert.assertEquals(-1.0, a.minInColumn(3), Vectors.EPS);
}
private Matrix matrixA() {
return m(a(8.93, 5.88, 6.57, 9.3, 3.65, 0.08),
a(3.96, 8.26, 2.51, 9.61, 4.63, 6.12),// 1
a(7.37, 5.79, 8.8, 0.87, 7.83, 6.15),// 2
a(3.43, 9.08, 1.16, 2.3, 3.66, 4.93),// 3
a(7.05, 7.75, 8.11, 2.93, 9.04, 6.72)); // 4
}
@Test(expected = IndexOutOfBoundsException.class)
public void testSelect1() {
// Throw exception when row indices are invalid
Matrix a = matrixA();
int[] rowInd = new int[]{3, 4, 10}; // 10 is too large of a row index
int[] colInd = new int[]{0, 1, 2};
a.select(rowInd, colInd);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testSelect2() {
// Throw exception when column indices are invalid
Matrix a = matrixA();
int[] rowInd = new int[]{0, 1, 2};
int[] colInd = new int[]{-1, 1, 2}; // -1 is a negative column index
a.select(rowInd, colInd);
}
@Test
public void testSelect3() {
// All columns and a subset of rows selected.
Matrix a = matrixA();
int[] rowInd = new int[]{1, 3, 4};
int[] colInd = new int[]{0, 1, 2, 3, 4, 5}; // all columns
Matrix b = m(a(3.96, 8.26, 2.51, 9.61, 4.63, 6.12),// 1
a(3.43, 9.08, 1.16, 2.3, 3.66, 4.93),// 3
a(7.05, 7.75, 8.11, 2.93, 9.04, 6.72));// 4
Assert.assertEquals(b, a.select(rowInd, colInd));
}
@Test
public void testSelect4() {
// All rows and a subset of columns selected.
Matrix a = matrixA();
int[] rowInd = new int[]{0, 1, 2, 3, 4};
int[] colInd = new int[]{0, 2, 4, 5}; // all columns
Matrix c = m(a(8.93, 6.57, 3.65, 0.08),// 0
a(3.96, 2.51, 4.63, 6.12),// 1
a(7.37, 8.8, 7.83, 6.15),// 2
a(3.43, 1.16, 3.66, 4.93),// 3
a(7.05, 8.11, 9.04, 6.72)); // 4
Assert.assertEquals(c, a.select(rowInd, colInd));
}
@Test
public void testSelect5() {
// A subset of rows and columns is selected.
Matrix a = matrixA();
int[] rowInd = new int[]{1, 3, 4};
int[] colInd = new int[]{2, 4, 5};
Matrix d = m(a(2.51, 4.63, 6.12),
a(1.16, 3.66, 4.93),// 3
a(8.11, 9.04, 6.72)); // 4
Assert.assertEquals(d, a.select(rowInd, colInd));
}
@Test
public void testSelect6() {
// Duplication of rows and columns.
Matrix a = matrixA();
int[] rowInd = new int[]{1, 3, 3, 4};
int[] colInd = new int[]{2, 2, 4, 5, 5};
Matrix d = m(a(2.51, 2.51, 4.63, 6.12, 6.12),// 1
a(1.16, 1.16, 3.66, 4.93, 4.93),// 3
a(1.16, 1.16, 3.66, 4.93, 4.93),// 3
a(8.11, 8.11, 9.04, 6.72, 6.72)); // 4
Assert.assertEquals(d, a.select(rowInd, colInd));
}
@Test
public void testFoldSum() {
Matrix d = m(a(6.436, 4.808, 3.923, 5.866),
a(7.072, 5.899, 4.771, 3.537),
a(7.282, 0.636, 0.010, 3.673),
a(5.833, 0.201, 6.941, 5.914),
a(5.757, 6.807, 7.830, 2.601),
a(0.434, 1.996, 9.329, 1.115));
Vector columnSums = v(32.814, 20.347, 32.804, 22.706);
for (int col = 0; col < d.columns(); col++) {
double sum = d.foldColumn(col, Vectors.asSumAccumulator(0.0));
Assert.assertEquals(sum, columnSums.get(col), Matrices.EPS);
}
double[] s = d.foldColumns(Vectors.asSumAccumulator(0.0));
Assert.assertEquals(DenseVector.fromArray(s), columnSums);
Vector rowSums = v(21.033, 21.279, 11.601, 18.889, 22.995, 12.874);
for (int row = 0; row < d.columns(); row++) {
double sum = d.foldRow(row, Vectors.asSumAccumulator(0.0));
Assert.assertEquals(sum, rowSums.get(row), Matrices.EPS);
}
s = d.foldRows(Vectors.asSumAccumulator(0.0));
Assert.assertEquals(DenseVector.fromArray(s), rowSums);
}
@Test
public void testDiagonalMatrixPredicate() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 1.0, 0.0),
a(0.0, 0.0, 1.0));
Assert.assertTrue(a.is(Matrices.DIAGONAL_MATRIX));
Matrix b = m(a(0.0, 0.0, 0.0),
a(2.0, 1.0, 0.0),
a(0.0, 0.0, 1.0));
Assert.assertFalse(b.is(Matrices.DIAGONAL_MATRIX));
}
@Test
public void testIdentityMatrixPredicate() {
Matrix a = m(a(1.0, 0.0, 0.0),
a(0.0, 1.0, 0.0),
a(0.0, 0.0, 1.0));
Assert.assertTrue(a.is(Matrices.IDENTITY_MATRIX));
Matrix b = m(a(0.0, 0.0, 0.0),
a(1.0, 0.0, 0.0),
a(0.0, 0.0, 1.0));
Assert.assertFalse(b.is(Matrices.IDENTITY_MATRIX));
}
@Test
public void testZeroMatrixPredicate() {
Matrix a = m(a(0.0, 0.0, 0.0),
a(0.0, 0.0, 0.0));
Assert.assertTrue(a.is(Matrices.ZERO_MATRIX));
Matrix b = m(a(0.0, 0.0, 0.0),
a(0.0, 0.0, 0.0),
a(0.0, 0.0, 1.0));
Assert.assertFalse(b.is(Matrices.ZERO_MATRIX));
}
@Test
public void testTridiagonalMatrixPredicate() {
Matrix a = m(a(0.0, 1.0, 0.0, 0.0),
a(1.0, 2.0, 3.0, 0.0),
a(0.0, 1.0, 0.0, 2.0),
a(0.0, 0.0, 1.0, 2.0));
Assert.assertTrue(a.is(Matrices.TRIDIAGONAL_MATRIX));
Matrix b = m(a(0.0, 1.0, 0.0, 0.0),
a(1.0, 2.0, 3.0, 0.0),
a(5.0, 0.0, 0.0, 2.0),
a(0.0, 0.0, 1.0, 2.0));
Assert.assertFalse(b.is(Matrices.TRIDIAGONAL_MATRIX));
}
@Test
public void testSymmetricMatrixPredicate() {
Matrix a = m(a(0.0, 1.0, 0.0, 0.0),
a(1.0, 2.0, 3.0, 5.0),
a(0.0, 3.0, 0.0, 0.0),
a(0.0, 5.0, 0.0, 2.0));
Assert.assertTrue(a.is(Matrices.SYMMETRIC_MATRIX));
Matrix b = m(a(0.0, 0.0, 0.0, 0.0),
a(0.0, 2.0, 3.0, 0.0),
a(3.0, 3.0, 0.0, 0.0),
a(0.0, 0.0, 0.0, 2.0));
Assert.assertFalse(b.is(Matrices.SYMMETRIC_MATRIX));
}
@Test(expected = IndexOutOfBoundsException.class)
public void testGet_IndexCheck_RowNegative() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.get(-1, 1);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testGet_IndexCheck_ColumnNegative() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.get(1, -1);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testGet_IndexCheck_RowTooLarge() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.get(a.rows(), 1);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testGet_IndexCheck_ColumnTooLarge() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.get(1, a.columns());
}
@Test
public void testGet_IndexCheck_Valid() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
Assert.assertEquals(0.0, a.get(1, 1), 0.0);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testSet_IndexCheck_RowNegative() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.set(-1, 1, 1.0);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testSet_IndexCheck_ColumnNegative() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.set(1, -1, 1.0);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testSet_IndexCheck_RowTooLarge() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.set(a.rows(), 1, 1.0);
}
@Test(expected = IndexOutOfBoundsException.class)
public void testSet_IndexCheck_ColumnTooLarge() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.set(1, a.columns(), 1.0);
}
@Test
public void testSet_IndexCheck_Valid() {
Matrix a = m(a(0.0, 0.0, 0.0, 1.0, 0.0),
a(0.0, 0.0, 3.0, 0.0, 0.0));
a.set(1, 1, 1.0);
Assert.assertEquals(1.0, a.get(1, 1), 0.0);
}
@Test
public void testEqualsWithPrecision() throws Exception {
Matrix a = mz(0, 0);
Assert.assertTrue(a.equals(a, Matrices.EPS));
Assert.assertTrue(a.equals(a.copy(), Matrices.EPS));
Matrix b = mz(2, 2);
Matrix c = mz(2, 2);
Assert.assertTrue(b.equals(c, Matrices.EPS));
Assert.assertTrue(c.equals(b, Matrices.EPS));
Assert.assertFalse(b.equals(a, Matrices.EPS));
Assert.assertFalse(c.equals(a, Matrices.EPS));
Matrix d = m(a(1.0, 0.0),
a(0.0, 1.0));
Assert.assertFalse(d.equals(b, Matrices.EPS));
Assert.assertFalse(d.equals(a, Matrices.EPS));
Matrix e = m(a(Double.MIN_VALUE, Double.MIN_VALUE),
a(Double.MIN_VALUE, Double.MIN_VALUE));
Assert.assertTrue(e.equals(b, Matrices.EPS));
Matrix f = m(a(Double.MIN_NORMAL, Double.MIN_NORMAL),
a(Double.MIN_NORMAL, Double.MIN_NORMAL));
Assert.assertTrue(f.equals(b, Matrices.EPS));
Assert.assertTrue(f.equals(e, Matrices.EPS));
Assert.assertTrue(b.equals(f, Matrices.EPS));
Assert.assertTrue(e.equals(f, Matrices.EPS));
}
@Test
public void testEquals() throws Exception {
Matrix a = mz(0, 0);
Assert.assertTrue(a.equals(a));
Assert.assertTrue(a.copy().equals(a));
Matrix b = mz(2, 2);
Matrix c = mz(2, 2);
Assert.assertTrue(b.equals(c));
Assert.assertTrue(c.equals(b));
Assert.assertFalse(b.equals(a));
Assert.assertFalse(c.equals(a));
Matrix d = m(a(1.0, 0.0),
a(0.0, 1.0));
Assert.assertFalse(d.equals(b));
Assert.assertFalse(d.equals(a));
Matrix e = m(a(Double.MIN_VALUE, Double.MIN_VALUE),
a(Double.MIN_VALUE, Double.MIN_VALUE));
Assert.assertTrue(e.equals(b));
Matrix f = m(a(Double.MIN_NORMAL, Double.MIN_NORMAL),
a(Double.MIN_NORMAL, Double.MIN_NORMAL));
Assert.assertTrue(f.equals(b));
Assert.assertTrue(f.equals(e));
Assert.assertTrue(b.equals(f));
Assert.assertTrue(e.equals(f));
}
@Test
public void testFromMatrixMarket() throws Exception {
String mm = "%%MatrixMarket matrix coordinate real general\n" +
"% This ASCII file represents a sparse 5x5 matrix with 8 \n" +
"% nonzeros in the Matrix Market format.\n" +
"%\n" +
" 5 5 8\n" +
" 1 1 1.000e+00\n" +
" 2 2 1.050e+01\n" +
" 3 3 1.500e-02\n" +
" 1 4 6.000e+00\n" +
" 4 2 2.505e+02\n" +
" 4 4 -2.800e+02\n" +
" 4 5 3.332e+01\n" +
" 5 5 1.200e+01";
RowMajorSparseMatrix matrix = RowMajorSparseMatrix.zero(5, 5, 8);
matrix.set(0, 0, 1.000e+00);
matrix.set(1, 1, 1.050e+01);
matrix.set(2, 2, 1.500e-02);
matrix.set(0, 3, 6.000e+00);
matrix.set(3, 1, 2.505e+02);
matrix.set(3, 3, -2.800e+02);
matrix.set(3, 4, 3.332e+01);
matrix.set(4, 4, 1.200e+01);
Matrix from_mm_matrix = Matrix.fromMatrixMarket(mm);
Assert.assertNotNull(from_mm_matrix);
Assert.assertTrue(matrix.equals(from_mm_matrix));
String bcsstm02_mm = "%%MatrixMarket matrix coordinate real general\n" +
"16 16 15\n" +
"1 1 9.2138580510000e-02\n" +
"2 2 9.2138580510000e-02\n" +
"3 3 9.2138580510000e-02\n" +
"4 4 1.3799573798300e-01\n" +
"5 5 1.3799573798300e-01\n" +
"6 6 1.3799573798300e-01\n" +
"7 7 1.3799573798300e-01\n" +
"8 8 1.3799573798300e-01\n" +
"9 9 1.3799573798300e-01\n" +
"10 10 9.2138580510000e-02\n" +
"11 11 9.2138580510000e-02\n" +
"12 12 9.2138580510000e-02\n" +
"13 13 1.7282857345500e-01\n" +
"14 14 1.7282857345500e-01\n" +
"15 15 1.7282857345500e-01\n";
RowMajorSparseMatrix bcs_matrix = RowMajorSparseMatrix.zero(16, 16, 15);
bcs_matrix.set(0, 0, 9.2138580510000e-02);
bcs_matrix.set(1, 1, 9.2138580510000e-02);
bcs_matrix.set(2, 2, 9.2138580510000e-02);
bcs_matrix.set(3, 3, 1.3799573798300e-01);
bcs_matrix.set(4, 4, 1.3799573798300e-01);
bcs_matrix.set(5, 5, 1.3799573798300e-01);
bcs_matrix.set(6, 6, 1.3799573798300e-01);
bcs_matrix.set(7, 7, 1.3799573798300e-01);
bcs_matrix.set(8, 8, 1.3799573798300e-01);
bcs_matrix.set(9, 9, 9.2138580510000e-02);
bcs_matrix.set(10, 10, 9.2138580510000e-02);
bcs_matrix.set(11, 11, 9.2138580510000e-02);
bcs_matrix.set(12, 12, 1.7282857345500e-01);
bcs_matrix.set(13, 13, 1.7282857345500e-01);
bcs_matrix.set(14, 14, 1.7282857345500e-01);
Matrix bcs_mm_matrix = Matrix.fromMatrixMarket(bcsstm02_mm);
Assert.assertNotNull(bcs_mm_matrix);
Assert.assertTrue(bcs_matrix.equals(bcs_mm_matrix));
}
}