mirror of
https://github.com/yuzu-emu/FasTC
synced 2024-11-22 21:23:55 +00:00
355 lines
10 KiB
C++
355 lines
10 KiB
C++
/* FasTC
|
|
* Copyright (c) 2014 University of North Carolina at Chapel Hill.
|
|
* All rights reserved.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software and its
|
|
* documentation for educational, research, and non-profit purposes, without
|
|
* fee, and without a written agreement is hereby granted, provided that the
|
|
* above copyright notice, this paragraph, and the following four paragraphs
|
|
* appear in all copies.
|
|
*
|
|
* Permission to incorporate this software into commercial products may be
|
|
* obtained by contacting the authors or the Office of Technology Development
|
|
* at the University of North Carolina at Chapel Hill <otd@unc.edu>.
|
|
*
|
|
* This software program and documentation are copyrighted by the University of
|
|
* North Carolina at Chapel Hill. The software program and documentation are
|
|
* supplied "as is," without any accompanying services from the University of
|
|
* North Carolina at Chapel Hill or the authors. The University of North
|
|
* Carolina at Chapel Hill and the authors do not warrant that the operation of
|
|
* the program will be uninterrupted or error-free. The end-user understands
|
|
* that the program was developed for research purposes and is advised not to
|
|
* rely exclusively on the program for any reason.
|
|
*
|
|
* IN NO EVENT SHALL THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL OR THE
|
|
* AUTHORS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
|
|
* OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF
|
|
* THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF NORTH CAROLINA
|
|
* AT CHAPEL HILL OR THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
|
* DAMAGE.
|
|
*
|
|
* THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL AND THE AUTHORS SPECIFICALLY
|
|
* DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AND ANY
|
|
* STATUTORY WARRANTY OF NON-INFRINGEMENT. THE SOFTWARE PROVIDED HEREUNDER IS ON
|
|
* AN "AS IS" BASIS, AND THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL AND
|
|
* THE AUTHORS HAVE NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
|
|
* ENHANCEMENTS, OR MODIFICATIONS.
|
|
*
|
|
* Please send all BUG REPORTS to <pavel@cs.unc.edu>.
|
|
*
|
|
* The authors may be contacted via:
|
|
*
|
|
* Pavel Krajcevski
|
|
* Dept of Computer Science
|
|
* 201 S Columbia St
|
|
* Frederick P. Brooks, Jr. Computer Science Bldg
|
|
* Chapel Hill, NC 27599-3175
|
|
* USA
|
|
*
|
|
* <http://gamma.cs.unc.edu/FasTC/>
|
|
*/
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "MatrixBase.h"
|
|
|
|
static const float kEpsilon = 1e-6f;
|
|
|
|
TEST(MatrixBase, Constructors) {
|
|
FasTC::MatrixBase<float, 3, 4> m3f;
|
|
for(int j = 0; j < 3; j++)
|
|
for(int i = 0; i < 4; i++)
|
|
m3f[j*4+i] = static_cast<float>(i) / static_cast<float>(j+1);
|
|
|
|
FasTC::MatrixBase<double, 1, 1> m1d;
|
|
for(int j = 0; j < 1; j++)
|
|
for(int i = 0; i < 1; i++)
|
|
m1d[j*1+i] = 0.0;
|
|
|
|
FasTC::MatrixBase<int, 7, 200> m7i;
|
|
for(int j = 0; j < 7; j++)
|
|
for(int i = 0; i < 200; i++)
|
|
m7i[j*200+i] = i*j;
|
|
|
|
FasTC::MatrixBase<unsigned, 16, 16> m16u;
|
|
for(int j = 0; j < 16; j++)
|
|
for(int i = 0; i < 16; i++)
|
|
m16u[j*16+i] = j-i;
|
|
|
|
#define TEST_VECTOR_COPY_CONS(mat, t, n, m) \
|
|
do { \
|
|
FasTC::MatrixBase<t, n, m> d##mat (mat); \
|
|
for(int i = 0; i < n*m; i++) { \
|
|
EXPECT_EQ(d##mat [i], mat[i]); \
|
|
} \
|
|
} while(0) \
|
|
|
|
TEST_VECTOR_COPY_CONS(m3f, float, 3, 4);
|
|
TEST_VECTOR_COPY_CONS(m1d, double, 1, 1);
|
|
TEST_VECTOR_COPY_CONS(m7i, int, 7, 200);
|
|
TEST_VECTOR_COPY_CONS(m16u, unsigned, 16, 16);
|
|
|
|
#undef TEST_VECTOR_COPY_CONS
|
|
}
|
|
|
|
TEST(MatrixBase, Accessors) {
|
|
FasTC::MatrixBase<float, 3, 1> v3f;
|
|
v3f[0] = 1.0f;
|
|
v3f[1] = -2.3f;
|
|
v3f[2] = 1000;
|
|
|
|
for(int i = 0; i < 3; i++) {
|
|
EXPECT_EQ(v3f[i], v3f(i));
|
|
}
|
|
|
|
v3f(0) = -1.0f;
|
|
v3f(1) = 2.3f;
|
|
v3f(2) = -1000;
|
|
|
|
for(int i = 0; i < 3; i++) {
|
|
EXPECT_EQ(v3f(i), v3f[i]);
|
|
}
|
|
}
|
|
|
|
TEST(MatrixBase, PointerConversion) {
|
|
FasTC::MatrixBase<float, 2, 3> v3f;
|
|
v3f(0,0) = 1.0f;
|
|
v3f(0,1) = -2.3f;
|
|
v3f(0,2) = 1000.0f;
|
|
v3f(1,0) = 1.0f;
|
|
v3f(1,1) = -2.3f;
|
|
v3f(1,2) = 1000.0f;
|
|
|
|
float cmp[6] = { 1.0f, -2.3f, 1000.0f, 1.0f, -2.3f, 1000.0f };
|
|
const float *v3fp = v3f;
|
|
int result = memcmp(cmp, v3fp, 6 * sizeof(float));
|
|
EXPECT_EQ(result, 0);
|
|
|
|
cmp[0] = -1.0f;
|
|
cmp[1] = 2.3f;
|
|
cmp[2] = 1000.0f;
|
|
cmp[3] = -1.0f;
|
|
cmp[4] = 2.3f;
|
|
cmp[5] = 1000.0f;
|
|
v3f = cmp;
|
|
for(int i = 0; i < 3; i++) {
|
|
EXPECT_EQ(v3f[i], cmp[i]);
|
|
}
|
|
}
|
|
|
|
TEST(MatrixBase, CastVector) {
|
|
srand(static_cast<unsigned>(time(NULL)));
|
|
|
|
FasTC::MatrixBase<float, 3, 2> v3f;
|
|
for(int i = 0; i < 6; i++) {
|
|
v3f[i] = static_cast<float>(rand());
|
|
}
|
|
|
|
FasTC::MatrixBase<double, 3, 2> v3d = v3f;
|
|
FasTC::MatrixBase<int, 3, 2> v3i = v3f;
|
|
for(int i = 0; i < 3*2; i++) {
|
|
EXPECT_EQ(v3d(i), static_cast<double>(v3f(i)));
|
|
EXPECT_EQ(v3i(i), static_cast<int>(v3f(i)));
|
|
}
|
|
}
|
|
|
|
TEST(MatrixBase, MatrixMultiplication) {
|
|
FasTC::MatrixBase<int, 2, 3> a;
|
|
a(0, 0) = 1; a(0, 1) = 2; a(0, 2) = 3;
|
|
a(1, 0) = 4; a(1, 1) = 5; a(1, 2) = 6;
|
|
|
|
FasTC::MatrixBase<int, 3, 5> b;
|
|
b(0, 0) = -1; b(0, 1) = 2; b(0, 2) = -4; b(0, 3) = 5; b(0, 4) = 0;
|
|
b(1, 0) = 1; b(1, 1) = 2; b(1, 2) = 4; b(1, 3) = 6; b(1, 4) = 3;
|
|
b(2, 0) = -1; b(2, 1) = -2; b(2, 2) = -3; b(2, 3) = -4; b(2, 4) = 5;
|
|
|
|
FasTC::MatrixBase<float, 2, 5> amb = a * b;
|
|
EXPECT_NEAR(amb(0, 0), -2, kEpsilon);
|
|
EXPECT_NEAR(amb(0, 1), 0, kEpsilon);
|
|
EXPECT_NEAR(amb(0, 2), -5, kEpsilon);
|
|
EXPECT_NEAR(amb(0, 3), 5, kEpsilon);
|
|
EXPECT_NEAR(amb(0, 4), 21, kEpsilon);
|
|
|
|
EXPECT_NEAR(amb(1, 0), -5, kEpsilon);
|
|
EXPECT_NEAR(amb(1, 1), 6, kEpsilon);
|
|
EXPECT_NEAR(amb(1, 2), -14, kEpsilon);
|
|
EXPECT_NEAR(amb(1, 3), 26, kEpsilon);
|
|
EXPECT_NEAR(amb(1, 4), 45, kEpsilon);
|
|
}
|
|
|
|
TEST(MatrixBase, Transposition) {
|
|
FasTC::MatrixBase<int, 3, 5> a;
|
|
a(0, 0) = -1; a(0, 1) = 2; a(0, 2) = -4; a(0, 3) = 5; a(0, 4) = 0;
|
|
a(1, 0) = 1; a(1, 1) = 2; a(1, 2) = 4; a(1, 3) = 6; a(1, 4) = 3;
|
|
a(2, 0) = -1; a(2, 1) = -2; a(2, 2) = -3; a(2, 3) = -4; a(2, 4) = 5;
|
|
|
|
FasTC::MatrixBase<int, 5, 3> b = a.Transpose();
|
|
|
|
for(int i = 0; i < 3; i++) {
|
|
for(int j = 0; j < 5; j++) {
|
|
EXPECT_EQ(a(i, j), b(j, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(MatrixBase, VectorMultiplication) {
|
|
|
|
FasTC::MatrixBase<int, 3, 5> a;
|
|
a(0, 0) = -1; a(0, 1) = 2; a(0, 2) = -4; a(0, 3) = 5; a(0, 4) = 0;
|
|
a(1, 0) = 1; a(1, 1) = 2; a(1, 2) = 4; a(1, 3) = 6; a(1, 4) = 3;
|
|
a(2, 0) = -1; a(2, 1) = -2; a(2, 2) = -3; a(2, 3) = -4; a(2, 4) = 5;
|
|
|
|
FasTC::VectorBase<int, 5> v;
|
|
for(int i = 0; i < 5; i++) v[i] = i + 1;
|
|
|
|
FasTC::VectorBase<int, 3> u = a * v;
|
|
EXPECT_EQ(u[0], -1 + (2 * 2) - (4 * 3) + (5 * 4));
|
|
EXPECT_EQ(u[1], 1 + (2 * 2) + (4 * 3) + (6 * 4) + (3 * 5));
|
|
EXPECT_EQ(u[2], -1 + (-2 * 2) - (3 * 3) - (4 * 4) + (5 * 5));
|
|
|
|
/////
|
|
|
|
for(int i = 0; i < 3; i++) u[i] = i + 1;
|
|
v = u * a;
|
|
|
|
EXPECT_EQ(v[0], -1 + (1 * 2) - (1 * 3));
|
|
EXPECT_EQ(v[1], 2 + (2 * 2) - (2 * 3));
|
|
EXPECT_EQ(v[2], -4 + (4 * 2) - (3 * 3));
|
|
EXPECT_EQ(v[3], 5 + (6 * 2) - (4 * 3));
|
|
EXPECT_EQ(v[4], 0 + (3 * 2) + (5 * 3));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "MatrixSquare.h"
|
|
|
|
TEST(MatrixSquare, Constructors) {
|
|
FasTC::MatrixBase<int, 3, 3> m;
|
|
m(0, 0) = 1; m(0, 1) = 2; m(0, 2) = 3;
|
|
m(1, 0) = 2; m(1, 1) = 3; m(1, 2) = 4;
|
|
m(2, 0) = 3; m(2, 1) = 4; m(2, 2) = 5;
|
|
|
|
FasTC::MatrixSquare<int, 3> sqm (m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_EQ(m[i], sqm[i]);
|
|
}
|
|
|
|
FasTC::MatrixSquare<float, 3> fsqm(m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_NEAR(m[i], fsqm[i], kEpsilon);
|
|
}
|
|
|
|
FasTC::MatrixSquare<float, 3> fcsqm(sqm);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_NEAR(fcsqm[i], sqm[i], kEpsilon);
|
|
}
|
|
}
|
|
|
|
TEST(MatrixSquare, PowerMethod) {
|
|
FasTC::MatrixSquare<double, 2> A;
|
|
A(0, 0) = 0.8f; A(0, 1) = 0.3f;
|
|
A(1, 0) = 0.2f; A(1, 1) = 0.7f;
|
|
|
|
double e;
|
|
FasTC::VectorBase<double, 2> x;
|
|
A.PowerMethod(x, &e, 20, 200);
|
|
|
|
EXPECT_NEAR(x[0], 0.83205f, 0.0002);
|
|
EXPECT_NEAR(x[1], 0.5547f, 0.0002);
|
|
|
|
EXPECT_NEAR(e, 1.f, 0.0001);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Matrix2x2.h"
|
|
|
|
TEST(Matrix2x2, Constructors) {
|
|
FasTC::MatrixBase<int, 2, 2> m;
|
|
m(0, 0) = 1; m(0, 1) = 2;
|
|
m(1, 0) = 2; m(1, 1) = 3;
|
|
|
|
FasTC::MatrixSquare<int, 2> sqm (m);
|
|
for(int i = 0; i < 4; i++) {
|
|
EXPECT_EQ(m[i], sqm[i]);
|
|
}
|
|
|
|
FasTC::Matrix2x2<int> tbtm (m);
|
|
for(int i = 0; i < 4; i++) {
|
|
EXPECT_EQ(m[i], tbtm[i]);
|
|
}
|
|
|
|
FasTC::Matrix2x2<float> fsqm(m);
|
|
for(int i = 0; i < 4; i++) {
|
|
EXPECT_NEAR(m[i], fsqm[i], kEpsilon);
|
|
}
|
|
|
|
FasTC::Matrix2x2<float> fcsqm(sqm);
|
|
for(int i = 0; i < 4; i++) {
|
|
EXPECT_NEAR(fcsqm[i], sqm[i], kEpsilon);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Matrix3x3.h"
|
|
|
|
TEST(Matrix3x3, Constructors) {
|
|
FasTC::MatrixBase<int, 3, 3> m;
|
|
m(0, 0) = 1; m(0, 1) = 2; m(0, 2) = 3;
|
|
m(1, 0) = 2; m(1, 1) = 3; m(1, 2) = 4;
|
|
m(2, 0) = 3; m(2, 1) = 4; m(2, 2) = 5;
|
|
|
|
FasTC::MatrixSquare<int, 3> sqm (m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_EQ(m[i], sqm[i]);
|
|
}
|
|
|
|
FasTC::Matrix3x3<int> tbtm (m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_EQ(m[i], tbtm[i]);
|
|
}
|
|
|
|
FasTC::Matrix3x3<float> fsqm(m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_NEAR(m[i], fsqm[i], kEpsilon);
|
|
}
|
|
|
|
FasTC::Matrix3x3<float> fcsqm(sqm);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_NEAR(fcsqm[i], sqm[i], kEpsilon);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Matrix4x4.h"
|
|
|
|
TEST(Matrix4x4, Constructors) {
|
|
FasTC::MatrixBase<int, 4, 4> m;
|
|
m(0, 0) = 1; m(0, 1) = 2; m(0, 2) = 3; m(0, 3) = 4;
|
|
m(1, 0) = 2; m(1, 1) = 3; m(1, 2) = 4; m(1, 3) = 5;
|
|
m(2, 0) = 3; m(2, 1) = 4; m(2, 2) = 5; m(2, 3) = 6;
|
|
m(3, 0) = 4; m(3, 1) = 5; m(3, 2) = 6; m(3, 3) = 7;
|
|
|
|
FasTC::MatrixSquare<int, 4> sqm (m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_EQ(m[i], sqm[i]);
|
|
}
|
|
|
|
FasTC::Matrix4x4<int> tbtm (m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_EQ(m[i], tbtm[i]);
|
|
}
|
|
|
|
FasTC::Matrix4x4<float> fsqm(m);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_NEAR(m[i], fsqm[i], kEpsilon);
|
|
}
|
|
|
|
FasTC::Matrix4x4<float> fcsqm(sqm);
|
|
for(int i = 0; i < 9; i++) {
|
|
EXPECT_NEAR(fcsqm[i], sqm[i], kEpsilon);
|
|
}
|
|
}
|
|
|