Removed lambdas and initializer list ctors to be compatible with older cpp standards.
This commit is contained in:
SGrottel
parent
dd40903b74
commit
b8adc27808
235
glm/gtx/pca.inl
235
glm/gtx/pca.inl
@ -1,26 +1,32 @@
|
||||
/// @ref gtx_pca
|
||||
|
||||
#ifndef GLM_HAS_CXX11_STL
|
||||
#include <algorithm>
|
||||
#else
|
||||
#include <utility>
|
||||
#endif
|
||||
|
||||
namespace glm {
|
||||
|
||||
|
||||
template<length_t D, typename T, qualifier Q>
|
||||
GLM_INLINE mat<D, D, T, Q> computeCovarianceMatrix(vec<D, T, Q> const* v, size_t n)
|
||||
{
|
||||
return std::move(computeCovarianceMatrix<D, T, Q, vec<D, T, Q> const*>(v, v + n));
|
||||
return computeCovarianceMatrix<D, T, Q, vec<D, T, Q> const*>(v, v + n);
|
||||
}
|
||||
|
||||
|
||||
template<length_t D, typename T, qualifier Q>
|
||||
GLM_INLINE mat<D, D, T, Q> computeCovarianceMatrix(vec<D, T, Q> const* v, size_t n, vec<D, T, Q> const& c)
|
||||
{
|
||||
return std::move(computeCovarianceMatrix<D, T, Q, vec<D, T, Q> const*>(v, v + n, c));
|
||||
return computeCovarianceMatrix<D, T, Q, vec<D, T, Q> const*>(v, v + n, c);
|
||||
}
|
||||
|
||||
|
||||
template<length_t D, typename T, qualifier Q, typename I>
|
||||
GLM_FUNC_DECL mat<D, D, T, Q> computeCovarianceMatrix(I const& b, I const& e)
|
||||
{
|
||||
glm::mat<D, D, T, Q> m{ 0 };
|
||||
glm::mat<D, D, T, Q> m(0);
|
||||
|
||||
size_t cnt = 0;
|
||||
for (I i = b; i != e; i++)
|
||||
@ -33,14 +39,14 @@ namespace glm {
|
||||
}
|
||||
if (cnt > 0) m /= static_cast<T>(cnt);
|
||||
|
||||
return std::move(m);
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
template<length_t D, typename T, qualifier Q, typename I>
|
||||
GLM_FUNC_DECL mat<D, D, T, Q> computeCovarianceMatrix(I const& b, I const& e, vec<D, T, Q> const& c)
|
||||
{
|
||||
glm::mat<D, D, T, Q> m{ 0 };
|
||||
glm::mat<D, D, T, Q> m(0);
|
||||
glm::vec<D, T, Q> v;
|
||||
|
||||
size_t cnt = 0;
|
||||
@ -54,109 +60,21 @@ namespace glm {
|
||||
}
|
||||
if (cnt > 0) m /= static_cast<T>(cnt);
|
||||
|
||||
return std::move(m);
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
template<length_t D, typename T, qualifier Q>
|
||||
GLM_FUNC_DECL unsigned int findEigenvaluesSymReal
|
||||
(
|
||||
mat<D, D, T, Q> const& covarMat,
|
||||
vec<D, T, Q>& outEigenvalues,
|
||||
mat<D, D, T, Q>& outEigenvectors
|
||||
)
|
||||
namespace _internal_
|
||||
{
|
||||
T a[D * D]; // matrix -- input and workspace for algorithm (will be changed inplace)
|
||||
auto A = [&](length_t const& r, length_t const& c) -> T& { return a[r * D + c]; };
|
||||
T d[D]; // diagonal elements
|
||||
T e[D]; // off-diagonal elements
|
||||
|
||||
for (length_t r = 0; r < D; r++) {
|
||||
for (length_t c = 0; c < D; c++) {
|
||||
A(r, c) = covarMat[c][r];
|
||||
}
|
||||
}
|
||||
template<typename T>
|
||||
GLM_INLINE T transferSign(T const& v, T const& s)
|
||||
{
|
||||
return ((s) >= 0 ? glm::abs(v) : -glm::abs(v));
|
||||
};
|
||||
|
||||
// 1. Householder reduction.
|
||||
length_t l, k, j, i;
|
||||
T scale, hh, h, g, f;
|
||||
constexpr T epsilon = static_cast<T>(0.0000001);
|
||||
|
||||
for (i = D; i >= 2; i--) {
|
||||
l = i - 1;
|
||||
h = scale = 0;
|
||||
if (l > 1) {
|
||||
for (k = 1; k <= l; k++) {
|
||||
scale += glm::abs(A(i - 1, k - 1));
|
||||
}
|
||||
if (glm::equal<T>(scale, 0, epsilon)) {
|
||||
e[i - 1] = A(i - 1, l - 1);
|
||||
} else {
|
||||
for (k = 1; k <= l; k++) {
|
||||
A(i - 1, k - 1) /= scale;
|
||||
h += A(i - 1, k - 1) * A(i - 1, k - 1);
|
||||
}
|
||||
f = A(i - 1, l - 1);
|
||||
g = ((f >= 0) ? -glm::sqrt(h) : glm::sqrt(h));
|
||||
e[i - 1] = scale * g;
|
||||
h -= f * g;
|
||||
A(i - 1, l - 1) = f - g;
|
||||
f = 0;
|
||||
for (j = 1; j <= l; j++) {
|
||||
A(j - 1, i - 1) = A(i - 1, j - 1) / h;
|
||||
g = 0;
|
||||
for (k = 1; k <= j; k++) {
|
||||
g += A(j - 1, k - 1) * A(i - 1, k - 1);
|
||||
}
|
||||
for (k = j + 1; k <= l; k++) {
|
||||
g += A(k - 1, j - 1) * A(i - 1, k - 1);
|
||||
}
|
||||
e[j - 1] = g / h;
|
||||
f += e[j - 1] * A(i - 1, j - 1);
|
||||
}
|
||||
hh = f / (h + h);
|
||||
for (j = 1; j <= l; j++) {
|
||||
f = A(i - 1, j - 1);
|
||||
e[j - 1] = g = e[j - 1] - hh * f;
|
||||
for (k = 1; k <= j; k++) {
|
||||
A(j - 1, k - 1) -= (f * e[k - 1] + g * A(i - 1, k - 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
e[i - 1] = A(i - 1, l - 1);
|
||||
}
|
||||
d[i - 1] = h;
|
||||
}
|
||||
d[0] = 0;
|
||||
e[0] = 0;
|
||||
for (i = 1; i <= D; i++) {
|
||||
l = i - 1;
|
||||
if (!glm::equal<T>(d[i - 1], 0, epsilon)) {
|
||||
for (j = 1; j <= l; j++) {
|
||||
g = 0;
|
||||
for (k = 1; k <= l; k++) {
|
||||
g += A(i - 1, k - 1) * A(k - 1, j - 1);
|
||||
}
|
||||
for (k = 1; k <= l; k++) {
|
||||
A(k - 1, j - 1) -= g * A(k - 1, i - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
d[i - 1] = A(i - 1, i - 1);
|
||||
A(i - 1, i - 1) = 1;
|
||||
for (j = 1; j <= l; j++) {
|
||||
A(j - 1, i - 1) = A(i - 1, j - 1) = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Calculation of eigenvalues and eigenvectors (QL algorithm)
|
||||
length_t m, iter;
|
||||
T s, r, p, dd, c, b;
|
||||
const length_t MAX_ITER = 30;
|
||||
auto transferSign = [](T const& v, T const& s) { return ((s) >= 0 ? glm::abs(v) : -glm::abs(v)); };
|
||||
auto pythag = [](T const& a, T const& b) {
|
||||
constexpr T epsilon = static_cast<T>(0.0000001);
|
||||
template<typename T>
|
||||
GLM_INLINE T pythag(T const& a, T const& b) {
|
||||
static const T epsilon = static_cast<T>(0.0000001);
|
||||
T absa = glm::abs(a);
|
||||
T absb = glm::abs(b);
|
||||
if (absa > absb) {
|
||||
@ -170,6 +88,107 @@ namespace glm {
|
||||
return absb * glm::sqrt(static_cast<T>(1) + absa);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template<length_t D, typename T, qualifier Q>
|
||||
GLM_FUNC_DECL unsigned int findEigenvaluesSymReal
|
||||
(
|
||||
mat<D, D, T, Q> const& covarMat,
|
||||
vec<D, T, Q>& outEigenvalues,
|
||||
mat<D, D, T, Q>& outEigenvectors
|
||||
)
|
||||
{
|
||||
using _internal_::transferSign;
|
||||
using _internal_::pythag;
|
||||
|
||||
T a[D * D]; // matrix -- input and workspace for algorithm (will be changed inplace)
|
||||
T d[D]; // diagonal elements
|
||||
T e[D]; // off-diagonal elements
|
||||
|
||||
for (length_t r = 0; r < D; r++) {
|
||||
for (length_t c = 0; c < D; c++) {
|
||||
a[(r) * D + (c)] = covarMat[c][r];
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Householder reduction.
|
||||
length_t l, k, j, i;
|
||||
T scale, hh, h, g, f;
|
||||
static const T epsilon = static_cast<T>(0.0000001);
|
||||
|
||||
for (i = D; i >= 2; i--) {
|
||||
l = i - 1;
|
||||
h = scale = 0;
|
||||
if (l > 1) {
|
||||
for (k = 1; k <= l; k++) {
|
||||
scale += glm::abs(a[(i - 1) * D + (k - 1)]);
|
||||
}
|
||||
if (glm::equal<T>(scale, 0, epsilon)) {
|
||||
e[i - 1] = a[(i - 1) * D + (l - 1)];
|
||||
} else {
|
||||
for (k = 1; k <= l; k++) {
|
||||
a[(i - 1) * D + (k - 1)] /= scale;
|
||||
h += a[(i - 1) * D + (k - 1)] * a[(i - 1) * D + (k - 1)];
|
||||
}
|
||||
f = a[(i - 1) * D + (l - 1)];
|
||||
g = ((f >= 0) ? -glm::sqrt(h) : glm::sqrt(h));
|
||||
e[i - 1] = scale * g;
|
||||
h -= f * g;
|
||||
a[(i - 1) * D + (l - 1)] = f - g;
|
||||
f = 0;
|
||||
for (j = 1; j <= l; j++) {
|
||||
a[(j - 1) * D + (i - 1)] = a[(i - 1) * D + (j - 1)] / h;
|
||||
g = 0;
|
||||
for (k = 1; k <= j; k++) {
|
||||
g += a[(j - 1) * D + (k - 1)] * a[(i - 1) * D + (k - 1)];
|
||||
}
|
||||
for (k = j + 1; k <= l; k++) {
|
||||
g += a[(k - 1) * D + (j - 1)] * a[(i - 1) * D + (k - 1)];
|
||||
}
|
||||
e[j - 1] = g / h;
|
||||
f += e[j - 1] * a[(i - 1) * D + (j - 1)];
|
||||
}
|
||||
hh = f / (h + h);
|
||||
for (j = 1; j <= l; j++) {
|
||||
f = a[(i - 1) * D + (j - 1)];
|
||||
e[j - 1] = g = e[j - 1] - hh * f;
|
||||
for (k = 1; k <= j; k++) {
|
||||
a[(j - 1) * D + (k - 1)] -= (f * e[k - 1] + g * a[(i - 1) * D + (k - 1)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
e[i - 1] = a[(i - 1) * D + (l - 1)];
|
||||
}
|
||||
d[i - 1] = h;
|
||||
}
|
||||
d[0] = 0;
|
||||
e[0] = 0;
|
||||
for (i = 1; i <= D; i++) {
|
||||
l = i - 1;
|
||||
if (!glm::equal<T>(d[i - 1], 0, epsilon)) {
|
||||
for (j = 1; j <= l; j++) {
|
||||
g = 0;
|
||||
for (k = 1; k <= l; k++) {
|
||||
g += a[(i - 1) * D + (k - 1)] * a[(k - 1) * D + (j - 1)];
|
||||
}
|
||||
for (k = 1; k <= l; k++) {
|
||||
a[(k - 1) * D + (j - 1)] -= g * a[(k - 1) * D + (i - 1)];
|
||||
}
|
||||
}
|
||||
}
|
||||
d[i - 1] = a[(i - 1) * D + (i - 1)];
|
||||
a[(i - 1) * D + (i - 1)] = 1;
|
||||
for (j = 1; j <= l; j++) {
|
||||
a[(j - 1) * D + (i - 1)] = a[(i - 1) * D + (j - 1)] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Calculation of eigenvalues and eigenvectors (QL algorithm)
|
||||
length_t m, iter;
|
||||
T s, r, p, dd, c, b;
|
||||
const length_t MAX_ITER = 30;
|
||||
|
||||
for (i = 2; i <= D; i++) {
|
||||
e[i - 2] = e[i - 1];
|
||||
}
|
||||
@ -187,7 +206,7 @@ namespace glm {
|
||||
return 0; // Too many iterations in FindEigenvalues
|
||||
}
|
||||
g = (d[l - 1 + 1] - d[l - 1]) / (2 * e[l - 1]);
|
||||
r = pythag(g, 1);
|
||||
r = pythag<T>(g, 1);
|
||||
g = d[m - 1] - d[l - 1] + e[l - 1] / (g + transferSign(r, g));
|
||||
s = c = 1;
|
||||
p = 0;
|
||||
@ -207,9 +226,9 @@ namespace glm {
|
||||
d[i - 1 + 1] = g + (p = s * r);
|
||||
g = c * r - b;
|
||||
for (k = 1; k <= D; k++) {
|
||||
f = A(k - 1, i - 1 + 1);
|
||||
A(k - 1, i - 1 + 1) = s * A(k - 1, i - 1) + c * f;
|
||||
A(k - 1, i - 1) = c * A(k - 1, i - 1) - s * f;
|
||||
f = a[(k - 1) * D + (i - 1 + 1)];
|
||||
a[(k - 1) * D + (i - 1 + 1)] = s * a[(k - 1) * D + (i - 1)] + c * f;
|
||||
a[(k - 1) * D + (i - 1)] = c * a[(k - 1) * D + (i - 1)] - s * f;
|
||||
}
|
||||
}
|
||||
if (glm::equal<T>(r, 0, epsilon) && (i >= l)) continue;
|
||||
@ -225,7 +244,7 @@ namespace glm {
|
||||
outEigenvalues[i] = d[i];
|
||||
for(i = 0; i < D; i++)
|
||||
for(j = 0; j < D; j++)
|
||||
outEigenvectors[i][j] = A(j, i);
|
||||
outEigenvectors[i][j] = a[(j) * D + (i)];
|
||||
|
||||
return D;
|
||||
}
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#define GLM_ENABLE_EXPERIMENTAL
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtx/pca.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <random>
|
||||
@ -18,7 +19,7 @@ namespace _1aga
|
||||
{
|
||||
// x,y,z coordinates copied from RCSB PDB file of 1AGA
|
||||
// w coordinate randomized with standard normal distribution
|
||||
constexpr double _1aga[] = {
|
||||
static const double _1aga[] = {
|
||||
3.219, -0.637, 19.462, 2.286,
|
||||
4.519, 0.024, 18.980, -0.828,
|
||||
4.163, 1.425, 18.481, -0.810,
|
||||
@ -146,17 +147,17 @@ namespace _1aga
|
||||
3.830, 3.522, 5.367, -0.302,
|
||||
5.150, 4.461, 2.116, -1.615
|
||||
};
|
||||
constexpr size_t _1agaSize = sizeof(_1aga) / (4 * sizeof(double));
|
||||
static const size_t _1agaSize = sizeof(_1aga) / (4 * sizeof(double));
|
||||
|
||||
outTestData.resize(_1agaSize);
|
||||
for(size_t i = 0; i < _1agaSize; ++i)
|
||||
for(size_t d = 0; d < vec::length(); ++d)
|
||||
for(size_t d = 0; d < static_cast<size_t>(vec::length()); ++d)
|
||||
outTestData[i][d] = static_cast<typename vec::value_type>(_1aga[i * 4 + d]);
|
||||
}
|
||||
|
||||
void getExpectedCovarDataPtr(const double*& ptr)
|
||||
{
|
||||
static constexpr double _1agaCovar4x4d[] = {
|
||||
static const double _1agaCovar4x4d[] = {
|
||||
9.624340680272107, -0.000066573696146, -4.293213765684049, 0.018793741874528,
|
||||
-0.000066573696146, 9.624439378684805, 5.351138726379443, -0.115692591458806,
|
||||
-4.293213765684049, 5.351138726379443, 35.628485496346691, 0.908742392542202,
|
||||
@ -167,7 +168,7 @@ namespace _1aga
|
||||
void getExpectedCovarDataPtr(const float*& ptr)
|
||||
{
|
||||
// note: the value difference to `_1agaCovar4x4d` is due to the numeric error propagation during computation of the covariance matrix.
|
||||
static constexpr float _1agaCovar4x4f[] = {
|
||||
static const float _1agaCovar4x4f[] = {
|
||||
9.624336242675781f, -0.000066711785621f, -4.293214797973633f, 0.018793795257807f,
|
||||
-0.000066711785621f, 9.624438285827637f, 5.351140022277832f, -0.115692682564259f,
|
||||
-4.293214797973633f, 5.351140022277832f, 35.628479003906250f, 0.908742427825928f,
|
||||
@ -191,10 +192,10 @@ namespace _1aga
|
||||
template<glm::length_t D, typename T> void getExpectedEigenvaluesEigenvectorsDataPtr(const T*& evals, const T*& evecs);
|
||||
template<> void getExpectedEigenvaluesEigenvectorsDataPtr<2, float>(const float*& evals, const float*& evecs)
|
||||
{
|
||||
static constexpr float expectedEvals[] = {
|
||||
static const float expectedEvals[] = {
|
||||
9.624471664428711f, 9.624302864074707f
|
||||
};
|
||||
static constexpr float expectedEvecs[] = {
|
||||
static const float expectedEvecs[] = {
|
||||
-0.443000972270966f, 0.896521151065826f,
|
||||
0.896521151065826f, 0.443000972270966f
|
||||
};
|
||||
@ -203,10 +204,10 @@ namespace _1aga
|
||||
}
|
||||
template<> void getExpectedEigenvaluesEigenvectorsDataPtr<2, double>(const double*& evals, const double*& evecs)
|
||||
{
|
||||
static constexpr double expectedEvals[] = {
|
||||
static const double expectedEvals[] = {
|
||||
9.624472899262972, 9.624307159693940
|
||||
};
|
||||
static constexpr double expectedEvecs[] = {
|
||||
static const double expectedEvecs[] = {
|
||||
-0.449720461624363, 0.893169360421846,
|
||||
0.893169360421846, 0.449720461624363
|
||||
};
|
||||
@ -215,10 +216,10 @@ namespace _1aga
|
||||
}
|
||||
template<> void getExpectedEigenvaluesEigenvectorsDataPtr<3, float>(const float*& evals, const float*& evecs)
|
||||
{
|
||||
static constexpr float expectedEvals[] = {
|
||||
static const float expectedEvals[] = {
|
||||
37.327442169189453f, 9.624311447143555f, 7.925499439239502f
|
||||
};
|
||||
static constexpr float expectedEvecs[] = {
|
||||
static const float expectedEvecs[] = {
|
||||
-0.150428697466850f, 0.187497511506081f, 0.970678031444550f,
|
||||
0.779980957508087f, 0.625803351402283f, -0.000005212802080f,
|
||||
0.607454538345337f, -0.757109522819519f, 0.240383237600327f
|
||||
@ -228,10 +229,10 @@ namespace _1aga
|
||||
}
|
||||
template<> void getExpectedEigenvaluesEigenvectorsDataPtr<3, double>(const double*& evals, const double*& evecs)
|
||||
{
|
||||
static constexpr double expectedEvals[] = {
|
||||
static const double expectedEvals[] = {
|
||||
37.327449427468345, 9.624314341614987, 7.925501786220276
|
||||
};
|
||||
static constexpr double expectedEvecs[] = {
|
||||
static const double expectedEvecs[] = {
|
||||
-0.150428640509585, 0.187497426513576, 0.970678082149394,
|
||||
0.779981605126846, 0.625802441381904, -0.000004919018357,
|
||||
0.607453635908278, -0.757110308615089, 0.240383154173870
|
||||
@ -241,10 +242,10 @@ namespace _1aga
|
||||
}
|
||||
template<> void getExpectedEigenvaluesEigenvectorsDataPtr<4, float>(const float*& evals, const float*& evecs)
|
||||
{
|
||||
static constexpr float expectedEvals[] = {
|
||||
static const float expectedEvals[] = {
|
||||
37.347740173339844f, 9.624703407287598f, 7.940164566040039f, 1.061712265014648f
|
||||
};
|
||||
static constexpr float expectedEvecs[] = {
|
||||
static const float expectedEvecs[] = {
|
||||
-0.150269940495491f, 0.187220811843872f, 0.970467865467072f, 0.023652425035834f,
|
||||
0.779159665107727f, 0.626788496971130f, -0.000105984276161f, -0.006797631736845f,
|
||||
0.608242213726044f, -0.755563497543335f, 0.238818943500519f, 0.046158745884895f,
|
||||
@ -255,10 +256,10 @@ namespace _1aga
|
||||
}
|
||||
template<> void getExpectedEigenvaluesEigenvectorsDataPtr<4, double>(const double*& evals, const double*& evecs)
|
||||
{
|
||||
static constexpr double expectedEvals[] = {
|
||||
static const double expectedEvals[] = {
|
||||
37.347738991879226, 9.624706889211053, 7.940170752816341, 1.061708639965897
|
||||
};
|
||||
static constexpr double expectedEvecs[] = {
|
||||
static const double expectedEvecs[] = {
|
||||
-0.150269954805403, 0.187220917596058, 0.970467838469868, 0.023652551509145,
|
||||
0.779159831346545, 0.626788431871120, -0.000105940250315, -0.006797622027466,
|
||||
0.608241962267880, -0.755563776664248, 0.238818902950296, 0.046158707986616,
|
||||
@ -299,13 +300,23 @@ vec computeCenter(const std::vector<vec>& testData)
|
||||
std::fill(c, c + vec::length(), 0.0);
|
||||
|
||||
for(vec const& v : testData)
|
||||
for(size_t d = 0; d < vec::length(); ++d)
|
||||
for(size_t d = 0; d < static_cast<size_t>(vec::length()); ++d)
|
||||
c[d] += static_cast<double>(v[d]);
|
||||
|
||||
vec cVec;
|
||||
for(size_t d = 0; d < vec::length(); ++d)
|
||||
for(size_t d = 0; d < static_cast<size_t>(vec::length()); ++d)
|
||||
cVec[d] = static_cast<typename vec::value_type>(c[d] / static_cast<double>(testData.size()));
|
||||
return std::move(cVec);
|
||||
return cVec;
|
||||
}
|
||||
|
||||
template<glm::length_t D, typename T, glm::qualifier Q>
|
||||
bool matrixEpsilonEqual(glm::mat<D, D, T, Q> const& a, glm::mat<D, D, T, Q> const& b)
|
||||
{
|
||||
for (int c = 0; c < D; ++c)
|
||||
for (int r = 0; r < D; ++r)
|
||||
if (!glm::epsilonEqual(a[c][r], b[c][r], static_cast<T>(0.000001)))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Test sorting of Eigenvalue&Eigenvector lists. Use exhaustive search.
|
||||
@ -313,26 +324,22 @@ template<glm::length_t D, typename T, glm::qualifier Q>
|
||||
int testEigenvalueSort()
|
||||
{
|
||||
// Test input data: four arbitrary values
|
||||
constexpr glm::vec<D, T, Q> refVal
|
||||
{
|
||||
glm::vec<4, T, Q>
|
||||
{
|
||||
static const glm::vec<D, T, Q> refVal(
|
||||
glm::vec<4, T, Q>(
|
||||
10, 8, 6, 4
|
||||
}
|
||||
};
|
||||
)
|
||||
);
|
||||
// Test input data: four arbitrary vectors, which can be matched to the above values
|
||||
constexpr glm::mat<D, D, T, Q> refVec
|
||||
{
|
||||
glm::mat<4, 4, T, Q>
|
||||
{
|
||||
static const glm::mat<D, D, T, Q> refVec(
|
||||
glm::mat<4, 4, T, Q>(
|
||||
10, 20, 5, 40,
|
||||
8, 16, 4, 32,
|
||||
6, 12, 3, 24,
|
||||
4, 8, 2, 16
|
||||
}
|
||||
};
|
||||
)
|
||||
);
|
||||
// Permutations of test input data for exhaustive check, based on `D` (1 <= D <= 4)
|
||||
constexpr int permutationCount[]
|
||||
static const int permutationCount[]
|
||||
{
|
||||
0,
|
||||
1,
|
||||
@ -341,7 +348,7 @@ int testEigenvalueSort()
|
||||
24
|
||||
};
|
||||
// The permutations t perform, based on `D` (1 <= D <= 4)
|
||||
constexpr glm::ivec4 permutation[]
|
||||
static const glm::ivec4 permutation[]
|
||||
{
|
||||
{ 0, 1, 2, 3 },
|
||||
{ 1, 0, 2, 3 }, // last for D = 2
|
||||
@ -368,32 +375,11 @@ int testEigenvalueSort()
|
||||
{ 3, 2, 0, 1 },
|
||||
{ 3, 2, 1, 0 } // last for D = 4
|
||||
};
|
||||
// Lambda utility to check the result
|
||||
auto checkResult = [&refVal,&refVec](glm::vec<D, T, Q> const& value, glm::mat<D, D, T, Q> const& vector)
|
||||
{
|
||||
constexpr T epsilon = static_cast<T>(0.0000001);
|
||||
// check that values are ordered ascending
|
||||
for(int i = 1; i < D; ++i)
|
||||
{
|
||||
if(value[0] < value[1])
|
||||
return false;
|
||||
}
|
||||
// check that values and vectors are equal to the reference values
|
||||
for(int i = 0; i < D; ++i)
|
||||
{
|
||||
if(!glm::equal<T>(refVal[i], value[i], epsilon))
|
||||
return false;
|
||||
for(int j = 0; j < D; ++j)
|
||||
{
|
||||
if(!glm::equal<T>(refVec[i][j], vector[i][j], epsilon))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true; // all matched
|
||||
};
|
||||
|
||||
// initial sanity check
|
||||
if(!checkResult(refVal, refVec))
|
||||
if(!glm::all(glm::epsilonEqual(refVal, refVal, static_cast<T>(0.000001))))
|
||||
return 1;
|
||||
if(!matrixEpsilonEqual(refVec, refVec))
|
||||
return 1;
|
||||
|
||||
// Exhaustive search through all permutations
|
||||
@ -409,8 +395,10 @@ int testEigenvalueSort()
|
||||
|
||||
glm::sortEigenvalues(testVal, testVec);
|
||||
|
||||
if(!checkResult(testVal, testVec))
|
||||
return 2 + p;
|
||||
if (!glm::all(glm::epsilonEqual(testVal, refVal, static_cast<T>(0.000001))))
|
||||
return 2 + p * 2;
|
||||
if (!matrixEpsilonEqual(testVec, refVec))
|
||||
return 2 + 1 + p * 2;
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -435,7 +423,7 @@ int testCovar(unsigned int dataSize, unsigned int randomEngineSeed)
|
||||
return 1;
|
||||
|
||||
// #2: test function variant consitency with random data
|
||||
std::default_random_engine rndEng{ randomEngineSeed };
|
||||
std::default_random_engine rndEng(randomEngineSeed);
|
||||
std::normal_distribution<T> normalDist;
|
||||
testData.resize(dataSize);
|
||||
// some common offset of all data
|
||||
@ -458,11 +446,11 @@ int testCovar(unsigned int dataSize, unsigned int randomEngineSeed)
|
||||
mat c3 = glm::computeCovarianceMatrix(testData.data(), testData.size(), center);
|
||||
mat c4 = glm::computeCovarianceMatrix<D, T, Q>(testData.rbegin(), testData.rend(), center);
|
||||
|
||||
if(c1 != c2)
|
||||
if(!matrixEpsilonEqual(c1, c2))
|
||||
return 1;
|
||||
if(c1 != c3)
|
||||
if(!matrixEpsilonEqual(c1, c3))
|
||||
return 1;
|
||||
if(c1 != c4)
|
||||
if(!matrixEpsilonEqual(c1, c4))
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
@ -506,7 +494,7 @@ int smokeTest()
|
||||
for(int x = -5; x <= 5; ++x)
|
||||
for(int y = -7; y <= 7; ++y)
|
||||
for(int z = -3; z <= 3; ++z)
|
||||
pts.push_back(vec3{ x, y, z });
|
||||
pts.push_back(vec3(x, y, z));
|
||||
|
||||
mat3 covar = glm::computeCovarianceMatrix(pts.data(), pts.size());
|
||||
mat3 eVec;
|
||||
@ -532,11 +520,11 @@ int smokeTest()
|
||||
std::swap(eVec[1], eVec[2]);
|
||||
}
|
||||
|
||||
if(!glm::all(glm::equal(glm::abs(eVec[0]), vec3{ 0, 1, 0 })))
|
||||
if(!glm::all(glm::equal(glm::abs(eVec[0]), vec3(0, 1, 0))))
|
||||
return 2;
|
||||
if(!glm::all(glm::equal(glm::abs(eVec[1]), vec3{ 1, 0, 0 })))
|
||||
if(!glm::all(glm::equal(glm::abs(eVec[1]), vec3(1, 0, 0))))
|
||||
return 3;
|
||||
if(!glm::all(glm::equal(glm::abs(eVec[2]), vec3{ 0, 0, 1 })))
|
||||
if(!glm::all(glm::equal(glm::abs(eVec[2]), vec3(0, 0, 1))))
|
||||
return 4;
|
||||
|
||||
return 0;
|
||||
@ -544,24 +532,24 @@ int smokeTest()
|
||||
|
||||
int rndTest(unsigned int randomEngineSeed)
|
||||
{
|
||||
std::default_random_engine rndEng{ randomEngineSeed };
|
||||
std::default_random_engine rndEng(randomEngineSeed);
|
||||
std::normal_distribution<double> normalDist;
|
||||
|
||||
// construct orthonormal system
|
||||
glm::dvec3 x{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
glm::dvec3 x(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
double l = glm::length(x);
|
||||
while(l < 0.000001)
|
||||
x = glm::dvec3{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
x = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
x = glm::normalize(x);
|
||||
glm::dvec3 y{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
glm::dvec3 y(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
l = glm::length(y);
|
||||
while(l < 0.000001)
|
||||
y = glm::dvec3{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
y = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
while(glm::abs(glm::dot(x, y)) < 0.000001)
|
||||
{
|
||||
y = glm::dvec3{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
y = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
while(l < 0.000001)
|
||||
y = glm::dvec3{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
y = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
}
|
||||
y = glm::normalize(y);
|
||||
glm::dvec3 z = glm::normalize(glm::cross(x, y));
|
||||
@ -574,13 +562,13 @@ int rndTest(unsigned int randomEngineSeed)
|
||||
|
||||
// generate input point data
|
||||
std::vector<glm::dvec3> ptData;
|
||||
constexpr int patters[] = {
|
||||
static const int patters[] = {
|
||||
8, 0, 0,
|
||||
4, 1, 2,
|
||||
0, 2, 0,
|
||||
0, 0, 4
|
||||
};
|
||||
glm::dvec3 offset{ normalDist(rndEng), normalDist(rndEng), normalDist(rndEng) };
|
||||
glm::dvec3 offset(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
|
||||
for(int p = 0; p < 4; ++p)
|
||||
for(int xs = 1; xs >= -1; xs -= 2)
|
||||
for(int ys = 1; ys >= -1; ys -= 2)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user