Пример #1
0
  @Test
  public void testNonSquareMatrix() {
    int[][] testInput = {
      {6, 0, 5},
      {0, 1, 1},
      {1, 5, 0},
      {0, 1, 0},
      {1, 5, 7},
      {1, 1, 1}
    };

    double[][] testOutput = {{}};

    double error = .00001;
    Matrix inputMatrix = new YaleSparseMatrix(6, 3);
    for (int row = 0; row < 6; ++row)
      for (int col = 0; col < 3; ++col) inputMatrix.set(row, col, testInput[row][col]);

    Transform transform = new TfIdfTransform();
    Matrix outputMatrix = transform.transform(inputMatrix);
    for (int row = 0; row < 6; ++row) {
      for (int col = 0; col < 3; ++col) System.out.println(outputMatrix.get(row, col));
      // assertEquals(testOutput[row][col],
      //             outputMatrix.get(row, col), error);
    }
  }
Пример #2
0
 @Test
 public void populate() {
   int row = 2, column = 2;
   int[] input = {1, 2, 3, 4};
   int[][] expected = {{1, 2}, {3, 4}};
   Matrix actualMatrix = new Matrix(row, column);
   actualMatrix.populate(input);
   assertArrayEquals(actualMatrix.matrix, expected);
 }
Пример #3
0
 @Test
 public void vectorProductTest() {
   Matrix m = Matrix.identityMatrix();
   Vector v = new Vector(2, 3, 4);
   Vector out = m.product(v);
   assertEquals(2, out.x, 0);
   assertEquals(3, out.y, 0);
   assertEquals(4, out.z, 0);
 }
Пример #4
0
 @Test
 public void determinantOfMatrix() {
   int[] numbers = {3, 4, 5, 6, 7, 8, 1, 9, 6};
   Matrix matrix = new Matrix(3, 3);
   matrix.populate(numbers);
   int[][] input = matrix.matrix;
   int result = matrix.determinant(input, 3);
   System.out.println(result);
   assertEquals(result, 33);
 }
Пример #5
0
 @Test
 public void testIsSquaredShouldFail() throws Exception {
   Matrix a =
       new Matrix(
           new double[][] {
             {2, 1, 1},
             {1, -1, -1},
           });
   assertEquals(false, a.isSquared());
 }
Пример #6
0
 @Test
 public void testIsRegularShouldSuccess() throws Exception {
   Matrix a =
       new Matrix(
           new double[][] {
             {1, 2, 3},
             {3, 2, 1},
             {2, 1, 3}
           });
   assertEquals(true, a.isRegular());
 }
Пример #7
0
 public static void testSet(Matrix m) {
   int rows = m.rows();
   int cols = m.columns();
   for (int trials = 0; trials < 100; ++trials) {
     int i = (int) (rows * Math.random());
     int j = (int) (cols * Math.random());
     double v = Math.random();
     m.set(i, j, v);
     assertEquals(v, m.get(i, j), 0.01);
   }
 }
Пример #8
0
 @Test
 public void testIsTriangularAnyShouldSuccess() throws Exception {
   Matrix a =
       new Matrix(
           new double[][] {
             {2, 0, 0},
             {1, 1, 0},
             {1, 2, 1}
           });
   assertEquals(true, a.isTriangular(Matrix.TriangleType.ANY, false));
 }
Пример #9
0
 @Test
 public void testGetDeterminant() throws Exception {
   Matrix a =
       new Matrix(
           new double[][] {
             {1, 2, 3},
             {3, 2, 1},
             {2, 1, 3}
           });
   double expected = -12;
   assertEquals(expected, a.getDeterminant(), 0);
 }
Пример #10
0
 @Test
 public void testGetTrace() throws Exception {
   Matrix a =
       new Matrix(
           new double[][] {
             {1, 2, 3},
             {3, 2, 1},
             {2, 1, 3}
           });
   double expected = 6.0;
   assertEquals(expected, a.getTrace(), 0);
 }
Пример #11
0
  @Test
  public void testGetTransposed() throws Exception {
    Matrix a =
        new Matrix(
            new double[][] {
              {1, 2, 3},
              {3, 2, 1},
              {2, 1, 3}
            });

    Matrix c = a.getTransposed();
    Matrix r =
        new Matrix(
            new double[][] {
              {1, 3, 2},
              {2, 2, 1},
              {3, 1, 3}
            });

    for (int i = 0; i < c.getNumRows(); i++) {
      for (int j = 0; j < c.getNumColumns(); j++) {
        assertEquals(r.getElement(i, j), c.getElement(i, j), 0);
      }
    }
  }
Пример #12
0
  @Test
  public void testGetCoMatrix() throws Exception {
    Matrix a =
        new Matrix(
            new double[][] {
              {1, 2, 3},
              {4, 5, 6},
              {5, 4, 3}
            });

    Matrix c = a.getCoMatrix();
    Matrix r =
        new Matrix(
            new double[][] {
              {-9, 18, -9},
              {6, -12, 6},
              {-3, 6, -3}
            });

    for (int i = 0; i < c.getNumRows(); i++) {
      for (int j = 0; j < c.getNumColumns(); j++) {
        assertEquals(r.getElement(i, j), c.getElement(i, j), 0);
      }
    }
  }
Пример #13
0
  @Test
  public void testGetInversed() throws Exception {
    Matrix a =
        new Matrix(
            new double[][] {
              {2, 1, 1},
              {1, -1, -1},
              {1, 2, 1}
            });

    Matrix c = a.getInversed();
    Matrix r =
        new Matrix(
            new double[][] {
              {1.0 / 3.0, 1.0 / 3.0, 0},
              {-(2.0 / 3.0), 1.0 / 3.0, 1},
              {1, -1, -1}
            });

    for (int i = 0; i < c.getNumRows(); i++) {
      for (int j = 0; j < c.getNumColumns(); j++) {
        assertEquals(r.getElement(i, j), c.getElement(i, j), 0);
      }
    }
  }
Пример #14
0
  @Test
  public void testMatrixTransformSize() {
    int[][] testInput = {
      {0, 0, 0, 0, 1, 1, 2, 4, 5, 0},
      {0, 1, 1, 2, 0, 1, 5, 2, 8, 10},
      {1, 5, 0, 0, 1, 0, 6, 3, 7, 9},
      {0, 1, 0, 1, 0, 1, 2, 0, 3, 0},
      {1, 5, 7, 0, 0, 1, 6, 10, 2, 45},
      {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
    };

    double[][] testOutput = {
      {
        0.00000, 0.00000, 0.00000, 0.00000, 0.17028, 0.10217, 0.04644, 0.10217, 0.09824, 0.00000,
      },
      {
        0.00000, 0.00810, 0.01171, 0.05268, 0.00000, 0.02107, 0.02395, 0.01054, 0.03242, 0.01621,
      },
      {
        0.07438, 0.08582, 0.00000, 0.00000, 0.07438, 0.00000, 0.06086, 0.03347, 0.06008, 0.03090,
      },
      {
        0.00000, 0.03929, 0.00000, 0.12771, 0.00000, 0.10217, 0.04644, 0.00000, 0.05894, 0.00000,
      },
      {
        0.03512, 0.04052, 0.08195, 0.00000, 0.00000, 0.02107, 0.02873, 0.05268, 0.00810, 0.07294,
      },
      {
        -0.03177, -0.00733, -0.01059, -0.02383, -0.03177, -0.01906, -0.00433, -0.00477, -0.00367,
        -0.00147,
      }
    };

    double error = .00001;
    Matrix inputMatrix = new YaleSparseMatrix(6, 10);
    for (int row = 0; row < 6; ++row)
      for (int col = 0; col < 10; ++col) inputMatrix.set(row, col, testInput[row][col]);

    Transform transform = new TfIdfTransform();
    Matrix outputMatrix = transform.transform(inputMatrix);
    for (int row = 0; row < 6; ++row) {
      for (int col = 0; col < 10; ++col)
        assertEquals(testOutput[row][col], outputMatrix.get(row, col), error);
    }
  }
Пример #15
0
 @Test
 public void testScalarProduct() throws Exception {
   Matrix a = new Matrix(new double[][] {{1, 2, 3}, {3, 2, 1}, {2, 1, 3}});
   Matrix b = a.scalarProduct(3);
   Matrix r = new Matrix(new double[][] {{3, 6, 9}, {9, 6, 3}, {6, 3, 9}});
   for (int i = 0; i < b.getNumRows(); i++) {
     for (int j = 0; j < b.getNumColumns(); j++) {
       assertEquals(r.getElement(i, j), b.getElement(i, j), 0);
     }
   }
 }
Пример #16
0
  @Test
  public void testSparseListMatrix() {
    List<SparseDoubleVector> vectors = new ArrayList<SparseDoubleVector>();
    for (double[] values : VALUES) vectors.add(new CompactSparseVector(values));
    Matrix m = new ListMatrix<SparseDoubleVector>(vectors);
    assertEquals(VALUES.length, m.rows());
    assertEquals(VALUES[0].length, m.columns());
    for (int r = 0; r < m.rows(); ++r)
      for (int c = 0; c < m.columns(); ++c) assertEquals(VALUES[r][c], m.get(r, c), .0001);

    m.set(0, 0, 0);
    assertEquals(0, vectors.get(0).get(0), .0001);

    for (int r = 0; r < m.rows(); ++r) assertEquals(vectors.get(r), m.getRowVector(r));
  }
Пример #17
0
 @Test
 public void testAddShouldPass() throws Exception {
   Matrix a = new Matrix(new double[][] {{1, 2, 3}, {3, 2, 1}, {2, 1, 3}});
   Matrix b = new Matrix(new double[][] {{1, 2, 3}, {3, 2, 1}, {2, 1, 3}});
   Matrix c = a.add(b);
   Matrix r = new Matrix(new double[][] {{2, 4, 6}, {6, 4, 2}, {4, 2, 6}});
   for (int i = 0; i < c.getNumRows(); i++) {
     for (int j = 0; j < c.getNumColumns(); j++) {
       assertEquals(r.getElement(i, j), c.getElement(i, j), 0);
     }
   }
 }
Пример #18
0
  @Test
  public void testIsTriangularStrictAnyShouldSuccess() throws Exception {
    Matrix a =
        new Matrix(
            new double[][] {
              {0, 0, 0},
              {1, 0, 0},
              {1, 2, 0}
            });
    assertEquals(true, a.isTriangular(Matrix.TriangleType.ANY, true));

    Matrix b =
        new Matrix(
            new double[][] {
              {0, 0, 0},
              {0, 0, 0},
              {0, 0, 0}
            });
    assertEquals(true, b.isTriangular(Matrix.TriangleType.INFERIOR, true));
  }
Пример #19
0
  @Test
  public void testMatrixMultiplication() throws Exception {
    Matrix a = new Matrix(new double[][] {{1, 2, 3}, {3, 2, 1}, {2, 1, 3}});

    Matrix b = new Matrix(new double[][] {{4, 5, 6}, {6, 5, 4}, {4, 6, 5}});

    Matrix c = a.matrixMultiplication(b);
    Matrix r = new Matrix(new double[][] {{28, 33, 29}, {28, 31, 31}, {26, 33, 31}});

    for (int i = 0; i < c.getNumRows(); i++) {
      for (int j = 0; j < c.getNumColumns(); j++) {
        assertEquals(r.getElement(i, j), c.getElement(i, j), 0);
      }
    }
  }
Пример #20
0
  @Test
  public void multiplyTwoMatrix() {
    int row = 2, column = 2;
    int[] firstArrayInput = {1, 2, 3, 4};
    int[] secondArrayInput = {2, 3, 4, 5};
    int[] expectedOutput = {11, 16, 19, 28};
    Matrix firstMatrix = new Matrix(row, column);
    Matrix secondMatrix = new Matrix(row, column);
    Matrix expectedMatrix = new Matrix(row, column);

    firstMatrix.populate(firstArrayInput);
    secondMatrix.populate(secondArrayInput);
    expectedMatrix.populate(expectedOutput);
    Matrix destinationMatrix = firstMatrix.multiply(secondMatrix);

    assertArrayEquals(destinationMatrix.matrix, expectedMatrix.matrix);
  }
Пример #21
0
 @Test
 public void testGetSubmatrix() throws Exception {
   Matrix a =
       new Matrix(
           new double[][] {
             {1, 2, 3},
             {3, 2, 1},
             {2, 1, 3}
           });
   Matrix b = a.getSubmatrix(1, 1);
   Matrix c =
       new Matrix(
           new double[][] {
             {1, 3},
             {2, 3}
           });
   for (int i = 0; i < c.getNumRows(); i++) {
     for (int j = 0; j < c.getNumColumns(); j++) {
       assertEquals(c.getElement(i, j), b.getElement(i, j), 0);
     }
   }
 }
  @Test
  public void basicOpsTest() {
    /** TRANSPOSE */
    double[][] basicArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
    Matrix m = new Matrix(basicArray);
    Matrix t = m.transpose();
    double[][] tArray = {{1, 4, 7, 10}, {2, 5, 8, 11}, {3, 6, 9, 12}};
    assertTrue(t.equals(new Matrix(tArray)));

    double[][] oneElArr = {{4}};
    Matrix oneEl = new Matrix(oneElArr);
    assertTrue(oneEl.transpose().equals(oneEl));

    /** MULTIPLICATION */
    Matrix scaledThree = m.multiply(3);
    double[][] scaledThreeArr = {{3, 6, 9}, {12, 15, 18}, {21, 24, 27}, {30, 33, 36}};
    assertTrue(scaledThree.equals(new Matrix(scaledThreeArr)));

    double[][] oneCol = {{1}, {1}, {1}};
    Matrix prod = m.multiply(new Matrix(oneCol));
    double[][] oneColProd = {{6}, {15}, {24}, {33}};
    assertTrue(prod.equals(new Matrix(oneColProd)));

    /** TOSTRING */
    assertEquals(
        m.toString(),
        "[[ 1.0, 2.0, 3.0 ], [ 4.0, 5.0, 6.0 ], [ 7.0, 8.0, 9.0 ], [ 10.0, 11.0, 12.0 ] ]");
  }
Пример #23
0
 @Test
 public void testIsRegularShouldFail() throws Exception {
   Matrix a = new Matrix(new double[][] {{1, 0, 3}, {3, 0, 1}, {2, 0, 3}});
   assertEquals(false, a.isRegular());
 }
  @Test
  public void moreOpsTest() {

    double[][] basicArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
    Matrix m = new Matrix(basicArray);

    /** MINOR ARRAY (2, 2) */
    double[][] minorArr = {{1, 3}, {7, 9}, {10, 12}};
    assertTrue(m.minor(2, 2).equals(new Matrix(minorArr)));

    /** DETERMINANT AND INVERSE */
    double[][] basicSquare = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    Matrix basicSquareMatrix = new Matrix(basicSquare);
    assertTrue(basicSquareMatrix.det() == 0);
    assertFalse(basicSquareMatrix.invertible()); // since det = 0;

    double[][] invertibleArr = {{7, 2, 1}, {0, 3, -1}, {-3, 4, -2}};
    Matrix invertibleMatrix = new Matrix(invertibleArr);
    double[][] inverse = {{-2, 8, -5}, {3, -11, 7}, {9, -34, 21}};
    assertTrue(invertibleMatrix.inverse().equals(new Matrix(inverse)));

    /** ECHELON FORM */
    double[][] echelonRes1 = {{1, 2, 0}, {0, 1, 1.25}, {0, 0, 1}};
    Matrix echelonMatrix1 = new Matrix(echelonRes1);

    double[][] testArr = {{1, 2, 0}, {0, 4, 5}, {3, 2, 6}};
    Matrix testMatrix = new Matrix(testArr);
    testMatrix.echelonForm();

    double[][] testArr2 = {{0, 4, 5}, {1, 2, 0}, {3, 2, 6}};
    Matrix testMatrix2 = new Matrix(testArr2);
    testMatrix2.echelonForm();

    assertTrue(testMatrix.equals(echelonMatrix1));
    assertTrue(testMatrix2.equals(echelonMatrix1));

    double[][] identityArr = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
    Matrix identityMatrix = new Matrix(identityArr);
    testMatrix.reducedEchelonForm();
    assertTrue(testMatrix.equals(identityMatrix));

    double[][] moreRows = {{4, 5}, {2, 1}, {0, 0}};
    Matrix moreRowsMatrix = new Matrix(moreRows);
    double[][] goodMoreRows = {{1, 0}, {0, 1}, {0, 0}};
    Matrix goodMoreRowsMatrix = new Matrix(goodMoreRows);
    moreRowsMatrix.reducedEchelonForm();
    assertTrue(moreRowsMatrix.equals(goodMoreRowsMatrix));

    double[][] moreCols = {{2, 4, 8}, {1, 2, 9}};
    Matrix moreColsMatrix = new Matrix(moreCols);
    double[][] goodMoreCols = {{1, 2, 0}, {0, 0, 1}};
    Matrix goodMoreColsMatrix = new Matrix(goodMoreCols);
    moreColsMatrix.reducedEchelonForm();
    assertTrue(moreColsMatrix.equals(goodMoreColsMatrix));

    /** PIVOT COUNT */
    assertTrue(moreColsMatrix.pivots() == 2);
    assertTrue(moreRowsMatrix.pivots() == 2);
    assertTrue(testMatrix.pivots() == 3);
  }