ui/gfx/matrix3_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <cmath>
   6 #include <limits>
   7
   8 #include "base/basictypes.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/gfx/matrix3_f.h"
  11
  12 namespace gfx {
  13 namespace {
  14
  15 TEST(Matrix3fTest, Constructors) {
  16   Matrix3F zeros = Matrix3F::Zeros();
  17   Matrix3F ones = Matrix3F::Ones();
  18   Matrix3F identity = Matrix3F::Identity();
  19
  20   Matrix3F product_ones = Matrix3F::FromOuterProduct(
  21       Vector3dF(1.0f, 1.0f, 1.0f), Vector3dF(1.0f, 1.0f, 1.0f));
  22   Matrix3F product_zeros = Matrix3F::FromOuterProduct(
  23       Vector3dF(1.0f, 1.0f, 1.0f), Vector3dF(0.0f, 0.0f, 0.0f));
  24   EXPECT_EQ(ones, product_ones);
  25   EXPECT_EQ(zeros, product_zeros);
  26
  27   for (int i = 0; i < 3; ++i) {
  28     for (int j = 0; j < 3; ++j)
  29       EXPECT_EQ(i == j ? 1.0f : 0.0f, identity.get(i, j));
  30   }
  31 }
  32
  33 TEST(Matrix3fTest, DataAccess) {
  34   Matrix3F matrix = Matrix3F::Ones();
  35   Matrix3F identity = Matrix3F::Identity();
  36
  37   EXPECT_EQ(Vector3dF(0.0f, 1.0f, 0.0f), identity.get_column(1));
  38   matrix.set(0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
  39   EXPECT_EQ(Vector3dF(2.0f, 5.0f, 8.0f), matrix.get_column(2));
  40   matrix.set_column(0, Vector3dF(0.1f, 0.2f, 0.3f));
  41   EXPECT_EQ(Vector3dF(0.1f, 0.2f, 0.3f), matrix.get_column(0));
  42
  43   EXPECT_EQ(0.1f, matrix.get(0, 0));
  44   EXPECT_EQ(5.0f, matrix.get(1, 2));
  45 }
  46
  47 TEST(Matrix3fTest, Determinant) {
  48   EXPECT_EQ(1.0f, Matrix3F::Identity().Determinant());
  49   EXPECT_EQ(0.0f, Matrix3F::Zeros().Determinant());
  50   EXPECT_EQ(0.0f, Matrix3F::Ones().Determinant());
  51
  52   // Now for something non-trivial...
  53   Matrix3F matrix = Matrix3F::Zeros();
  54   matrix.set(0, 5, 6, 8, 7, 0, 1, 9, 0);
  55   EXPECT_EQ(390.0f, matrix.Determinant());
  56   matrix.set(2, 0, 3 * matrix.get(0, 0));
  57   matrix.set(2, 1, 3 * matrix.get(0, 1));
  58   matrix.set(2, 2, 3 * matrix.get(0, 2));
  59   EXPECT_EQ(0, matrix.Determinant());
  60
  61   matrix.set(0.57f,  0.205f,  0.942f,
  62              0.314f,  0.845f,  0.826f,
  63              0.131f,  0.025f,  0.962f);
  64   EXPECT_NEAR(0.3149f, matrix.Determinant(), 0.0001f);
  65 }
  66
  67 TEST(Matrix3fTest, Inverse) {
  68   Matrix3F identity = Matrix3F::Identity();
  69   Matrix3F inv_identity = identity.Inverse();
  70   EXPECT_EQ(identity, inv_identity);
  71
  72   Matrix3F singular = Matrix3F::Zeros();
  73   singular.set(1.0f, 3.0f, 4.0f,
  74                2.0f, 11.0f, 5.0f,
  75                0.5f, 1.5f, 2.0f);
  76   EXPECT_EQ(0, singular.Determinant());
  77   EXPECT_EQ(Matrix3F::Zeros(), singular.Inverse());
  78
  79   Matrix3F regular = Matrix3F::Zeros();
  80   regular.set(0.57f,  0.205f,  0.942f,
  81               0.314f,  0.845f,  0.826f,
  82               0.131f,  0.025f,  0.962f);
  83   Matrix3F inv_regular = regular.Inverse();
  84   regular.set(2.51540616f, -0.55138018f, -1.98968043f,
  85               -0.61552266f,  1.34920184f, -0.55573636f,
  86               -0.32653861f,  0.04002158f,  1.32488726f);
  87   EXPECT_TRUE(regular.IsNear(inv_regular, 0.00001f));
  88 }
  89
  90 TEST(Matrix3fTest, EigenvectorsIdentity) {
  91   // This block tests the trivial case of eigenvalues of the identity matrix.
  92   Matrix3F identity = Matrix3F::Identity();
  93   Vector3dF eigenvals = identity.SolveEigenproblem(NULL);
  94   EXPECT_EQ(Vector3dF(1.0f, 1.0f, 1.0f), eigenvals);
  95 }
  96
  97 TEST(Matrix3fTest, EigenvectorsDiagonal)  {
  98   // This block tests the another trivial case of eigenvalues of a diagonal
  99   // matrix. Here we expect values to be sorted.
 100   Matrix3F matrix = Matrix3F::Zeros();
 101   matrix.set(0, 0, 1.0f);
 102   matrix.set(1, 1, -2.5f);
 103   matrix.set(2, 2, 3.14f);
 104   Matrix3F eigenvectors = Matrix3F::Zeros();
 105   Vector3dF eigenvals = matrix.SolveEigenproblem(&eigenvectors);
 106   EXPECT_EQ(Vector3dF(3.14f, 1.0f, -2.5f), eigenvals);
 107
 108   EXPECT_EQ(Vector3dF(0.0f, 0.0f, 1.0f), eigenvectors.get_column(0));
 109   EXPECT_EQ(Vector3dF(1.0f, 0.0f, 0.0f), eigenvectors.get_column(1));
 110   EXPECT_EQ(Vector3dF(0.0f, 1.0f, 0.0f), eigenvectors.get_column(2));
 111 }
 112
 113 TEST(Matrix3fTest, EigenvectorsNiceNotPositive)  {
 114   // This block tests computation of eigenvectors of a matrix where nice
 115   // round values are expected.
 116   Matrix3F matrix = Matrix3F::Zeros();
 117   // This is not a positive-definite matrix but eigenvalues and the first
 118   // eigenvector should nonetheless be computed correctly.
 119   matrix.set(3, 2, 4, 2, 0, 2, 4, 2, 3);
 120   Matrix3F eigenvectors = Matrix3F::Zeros();
 121   Vector3dF eigenvals = matrix.SolveEigenproblem(&eigenvectors);
 122   EXPECT_EQ(Vector3dF(8.0f, -1.0f, -1.0f), eigenvals);
 123
 124   Vector3dF expected_principal(0.66666667f, 0.33333333f, 0.66666667f);
 125   EXPECT_NEAR(0.0f,
 126               (expected_principal - eigenvectors.get_column(0)).Length(),
 127               0.000001f);
 128 }
 129
 130 TEST(Matrix3fTest, EigenvectorsPositiveDefinite) {
 131   // This block tests computation of eigenvectors of a matrix where output
 132   // is not as nice as above, but it actually meets the definition.
 133   Matrix3F matrix = Matrix3F::Zeros();
 134   Matrix3F eigenvectors = Matrix3F::Zeros();
 135   Matrix3F expected_eigenvectors = Matrix3F::Zeros();
 136   matrix.set(1, -1,  2, -1,  4,  5, 2,  5,  0);
 137   Vector3dF eigenvals =  matrix.SolveEigenproblem(&eigenvectors);
 138   Vector3dF expected_eigv(7.3996266f, 1.91197255f, -4.31159915f);
 139   expected_eigv -= eigenvals;
 140   EXPECT_NEAR(0, expected_eigv.LengthSquared(), 0.00001f);
 141   expected_eigenvectors.set(0.04926317f, -0.92135662f, -0.38558414f,
 142                             0.82134249f, 0.25703273f, -0.50924521f,
 143                             0.56830419f, -0.2916096f, 0.76941158f);
 144   EXPECT_TRUE(expected_eigenvectors.IsNear(eigenvectors, 0.00001f));
 145 }
 146
 147 }
 148 }