GenericMatrix/test_generic_matrix.cpp at master · oleg-liatte/GenericMatrix · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include "generic_matrix.hpp"
#include <catch.hpp>
#include <atomic>
#include <intrin.h>

namespace
{
using Matrix = GenericMatrix<int, 2, 2>;
using Vector = Matrix::row_type;

// rotation to 90 deg CW
constexpr Matrix s_cw =
{
	0, -1,
	1, 0
};

// rotation to 90 deg CCW
constexpr Matrix s_ccw =
{
	0, 1,
	-1, 0
};
} // namespace

TEST_CASE("GenericMatrix")
{
	Matrix m =
	{
		1, -2,
		2, 3
	};

	CHECK(m.get<0, 0>() == 1);
	CHECK(m.get<0, 1>() == -2);
	CHECK(m.get<1, 0>() == 2);
	CHECK(m.get<1, 1>() == 3);

	CHECK(m[0][0] == 1);
	CHECK(m[0][1] == -2);
	CHECK(m[1][0] == 2);
	CHECK(m[1][1] == 3);

	m.set<1, 0>(4);
	CHECK(m.get<1, 0>() == 4);
	CHECK(m[1][0] == 4);

	m[1][0] = 2;
	CHECK(m.get<1, 0>() == 2);
	CHECK(m[1][0] == 2);

	CHECK(m.determinant() == 7);
}

TEST_CASE("GenericMatrix inversion")
{
	auto d = s_ccw.determinant();
	CHECK(d == 1);

	auto inv = s_ccw.invert();
	CHECK(inv == s_cw);
}

TEST_CASE("GenericMatrix multiplication")
{
	auto m = s_ccw * s_cw;
	CHECK(m == Matrix::identity());
}

TEST_CASE("GenericMatrix vector transform")
{
	auto v = Vector{1, 0};
	auto vt = v * s_ccw;
	CHECK(vt == Vector{0, 1});
}

TEST_CASE("GenericMatrix point transform: origin")
{
	GenericMatrix<int, 2, 3> ccw =
	{
		0, 1,
		-1, 0,
		0, 0
	};

	Vector v = {0, 1};

	auto v2 = v * ccw;

	CHECK(v2 == Vector{-1, 0});
}

TEST_CASE("GenericMatrix point transform: pivot")
{
	using M = GenericMatrix<int, 3, 3>;
	using V = GenericVector<int, 3>;
	M ccw =
	{
		0, 1, 0,
		-1, 0, 0,
		0, 0, 1
	};

	M pivot =
	{
		1, 0, 0,
		0, 1, 0,
		1, 2, 1
	};

	auto ccwAroundPivot = pivot.invert() * ccw * pivot;

	V v = {1, 1, 1};

	v *= ccwAroundPivot;
	CHECK(v == V{2, 2, 1});

	v *= ccwAroundPivot;
	CHECK(v == V{1, 3, 1});

	v *= ccwAroundPivot;
	CHECK(v == V{0, 2, 1});

	v *= ccwAroundPivot;
	CHECK(v == V{1, 1, 1});
}