ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Math: merged constExpressions() test cases into other test cases. 

Simplifies the code and reduces duplicates.
pull/278/head
Vladimír Vondruš 13 years ago
parent
3e0e91d7db
commit
b28b90a9df
5 changed files with 105 additions and 160 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 61
      src/Math/Test/ComplexTest.cpp
  2. 48
      src/Math/Test/DualComplexTest.cpp
  3. 49
      src/Math/Test/DualQuaternionTest.cpp
  4. 53
      src/Math/Test/DualTest.cpp
  5. 54
      src/Math/Test/QuaternionTest.cpp

61
src/Math/Test/ComplexTest.cpp
Unescape View File

@ -37,12 +37,11 @@ class ComplexTest: public Corrade::TestSuite::Tester {
void construct();
void constructDefault();
void constructFromVector();
void constructCopy();
void compare();
void isNormalized();
void constExpressions();
void addSubtract();
void negated();
void multiplyDivideScalar();
@ -69,12 +68,11 @@ ComplexTest::ComplexTest() {
addTests({&ComplexTest::construct,
&ComplexTest::constructDefault,
&ComplexTest::constructFromVector,
&ComplexTest::constructCopy,
&ComplexTest::compare,
&ComplexTest::isNormalized,
&ComplexTest::constExpressions,
&ComplexTest::addSubtract,
&ComplexTest::negated,
&ComplexTest::multiplyDivideScalar,
@ -105,22 +103,35 @@ typedef Math::Matrix3<Float> Matrix3;
typedef Math::Matrix<2, Float> Matrix2;
void ComplexTest::construct() {
Complex c(0.5f, -3.7f);
CORRADE_COMPARE(c.real(), 0.5f);
CORRADE_COMPARE(c.imaginary(), -3.7f);
constexpr Complex a(0.5f, -3.7f);
CORRADE_COMPARE(a, Complex(0.5f, -3.7f));
constexpr Float b = a.real();
constexpr Float c = a.imaginary();
CORRADE_COMPARE(b, 0.5f);
CORRADE_COMPARE(c, -3.7f);
}
void ComplexTest::constructDefault() {
CORRADE_COMPARE(Complex(), Complex(1.0f, 0.0f));
CORRADE_COMPARE(Complex().length(), 1.0f);
constexpr Complex a;
CORRADE_COMPARE(a, Complex(1.0f, 0.0f));
CORRADE_COMPARE(a.length(), 1.0f);
}
void ComplexTest::constructFromVector() {
Vector2 vec(1.5f, -3.0f);
constexpr Vector2 vec(1.5f, -3.0f);
Complex a(vec);
constexpr Complex a(vec);
CORRADE_COMPARE(a, Complex(1.5f, -3.0f));
CORRADE_COMPARE(Vector2(a), vec);
constexpr Vector2 b(a);
CORRADE_COMPARE(b, vec);
}
void ComplexTest::constructCopy() {
constexpr Complex a(2.5f, -5.0f);
constexpr Complex b(a);
CORRADE_COMPARE(b, Complex(2.5f, -5.0f));
}
void ComplexTest::compare() {
@ -135,32 +146,6 @@ void ComplexTest::isNormalized() {
CORRADE_VERIFY(Complex::rotation(Deg(23.0f)).isNormalized());
}
void ComplexTest::constExpressions() {
/* Default constructor */
constexpr Complex a;
CORRADE_COMPARE(a, Complex(1.0f, 0.0f));
/* Value constructor */
constexpr Complex b(2.5f, -5.0f);
CORRADE_COMPARE(b, Complex(2.5f, -5.0f));
/* Vector constructor */
constexpr Complex c(Vector2(-1.0f, 2.2f));
CORRADE_COMPARE(c, Complex(-1.0f, 2.2f));
/* Copy constructor */
constexpr Complex d(b);
CORRADE_COMPARE(d, Complex(2.5f, -5.0f));
/* Data access */
constexpr Float e = b.real();
constexpr Float f = b.imaginary();
constexpr Vector2 g(b);
CORRADE_COMPARE(e, 2.5f);
CORRADE_COMPARE(f, -5.0f);
CORRADE_COMPARE(g, Vector2(2.5f, -5.0f));
}
void ComplexTest::addSubtract() {
Complex a( 1.7f, -3.7f);
Complex b(-3.6f, 0.2f);

48
src/Math/Test/DualComplexTest.cpp
Unescape View File

@ -37,11 +37,10 @@ class DualComplexTest: public Corrade::TestSuite::Tester {
void construct();
void constructDefault();
void constructFromVector();
void constructCopy();
void isNormalized();
void constExpressions();
void multiply();
void lengthSquared();
@ -75,11 +74,10 @@ DualComplexTest::DualComplexTest() {
addTests({&DualComplexTest::construct,
&DualComplexTest::constructDefault,
&DualComplexTest::constructFromVector,
&DualComplexTest::constructCopy,
&DualComplexTest::isNormalized,
&DualComplexTest::constExpressions,
&DualComplexTest::multiply,
&DualComplexTest::lengthSquared,
@ -102,18 +100,30 @@ DualComplexTest::DualComplexTest() {
}
void DualComplexTest::construct() {
DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f});
CORRADE_COMPARE(a.real(), Complex(-1.0f, 2.5f));
CORRADE_COMPARE(a.dual(), Complex(3.0f, -7.5f));
constexpr DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f});
CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
constexpr Complex b = a.real();
constexpr Complex c = a.dual();
CORRADE_COMPARE(b, Complex(-1.0f, 2.5f));
CORRADE_COMPARE(c, Complex(3.0f, -7.5f));
}
void DualComplexTest::constructDefault() {
CORRADE_COMPARE(DualComplex(), DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
CORRADE_COMPARE(DualComplex().length(), 1.0f);
constexpr DualComplex a;
CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
CORRADE_COMPARE(a.length(), 1.0f);
}
void DualComplexTest::constructFromVector() {
CORRADE_COMPARE(DualComplex(Vector2(1.5f, -3.0f)), DualComplex({1.0f, 0.0f}, {1.5f, -3.0f}));
constexpr DualComplex a(Vector2(1.5f, -3.0f));
CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {1.5f, -3.0f}));
}
void DualComplexTest::constructCopy() {
constexpr DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f});
constexpr DualComplex b(a);
CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
}
void DualComplexTest::isNormalized() {
@ -121,24 +131,6 @@ void DualComplexTest::isNormalized() {
CORRADE_VERIFY((DualComplex::rotation(Deg(23.0f))*DualComplex::translation({6.0f, 3.0f})).isNormalized());
}
void DualComplexTest::constExpressions() {
/* Default constructor */
constexpr DualComplex a;
CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
/* Value constructor */
constexpr DualComplex b({-1.0f, 2.5f}, {3.0f, -7.5f});
CORRADE_COMPARE(b, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
/* Vector constructor */
constexpr DualComplex c(Vector2(-3.0f, 7.5f));
CORRADE_COMPARE(c, DualComplex({}, {-3.0f, 7.5f}));
/* Copy constructor */
constexpr DualComplex d(b);
CORRADE_COMPARE(d, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
}
void DualComplexTest::multiply() {
DualComplex a({-1.5f, 2.0f}, { 3.0f, -6.5f});
DualComplex b({ 2.0f, -7.5f}, {-0.5f, 1.0f});;

49
src/Math/Test/DualQuaternionTest.cpp
Unescape View File

@ -36,11 +36,10 @@ class DualQuaternionTest: public Corrade::TestSuite::Tester {
void construct();
void constructDefault();
void constructFromVector();
void constructCopy();
void isNormalized();
void constExpressions();
void lengthSquared();
void length();
void normalized();
@ -73,11 +72,10 @@ DualQuaternionTest::DualQuaternionTest() {
addTests({&DualQuaternionTest::construct,
&DualQuaternionTest::constructDefault,
&DualQuaternionTest::constructFromVector,
&DualQuaternionTest::constructCopy,
&DualQuaternionTest::isNormalized,
&DualQuaternionTest::constExpressions,
&DualQuaternionTest::lengthSquared,
&DualQuaternionTest::length,
&DualQuaternionTest::normalized,
@ -99,18 +97,31 @@ DualQuaternionTest::DualQuaternionTest() {
}
void DualQuaternionTest::construct() {
DualQuaternion q({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f});
CORRADE_COMPARE(q.real(), Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
CORRADE_COMPARE(q.dual(), Quaternion({0.5f, -3.1f, 3.3f}, 2.0f));
constexpr DualQuaternion a({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f});
CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}));
constexpr Quaternion b = a.real();
CORRADE_COMPARE(b, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
constexpr Quaternion c = a.dual();
CORRADE_COMPARE(c, Quaternion({0.5f, -3.1f, 3.3f}, 2.0f));
}
void DualQuaternionTest::constructDefault() {
CORRADE_COMPARE(DualQuaternion(), DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
CORRADE_COMPARE(DualQuaternion().length(), 1.0f);
constexpr DualQuaternion a;
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
CORRADE_COMPARE(a.length(), 1.0f);
}
void DualQuaternionTest::constructFromVector() {
CORRADE_COMPARE(DualQuaternion(Vector3(1.0f, 2.0f, 3.0f)), DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.0f, 2.0f, 3.0f}, 0.0f}));
constexpr DualQuaternion a(Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.0f, 2.0f, 3.0f}, 0.0f}));
}
void DualQuaternionTest::constructCopy() {
constexpr DualQuaternion a({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f});
constexpr DualQuaternion b(a);
CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f}));
}
void DualQuaternionTest::isNormalized() {
@ -118,24 +129,6 @@ void DualQuaternionTest::isNormalized() {
CORRADE_VERIFY((DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis())*DualQuaternion::translation({3.0f, 1.0f, -0.5f})).isNormalized());
}
void DualQuaternionTest::constExpressions() {
/* Default constructor */
constexpr DualQuaternion a;
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
/* Value constructor */
constexpr DualQuaternion b({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f});
CORRADE_COMPARE(b, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f}));
/* Vector constructor */
constexpr DualQuaternion c(Vector3(1.5f, -5.0f, 3.0f));
CORRADE_COMPARE(c, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.5f, -5.0f, 3.0f}, 0.0f}));
/* Copy constructor */
constexpr DualQuaternion d(b);
CORRADE_COMPARE(d, DualQuaternion({{1.0f, 2.0f, -3.0f}, -3.5f}, {{4.5f, -7.0f, 2.0f}, 1.0f}));
}
void DualQuaternionTest::lengthSquared() {
DualQuaternion a({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.0f, 3.0f}, 2.0f});
CORRADE_COMPARE(a.lengthSquared(), Dual(30.0f, -9.0f));

53
src/Math/Test/DualTest.cpp
Unescape View File

@ -35,9 +35,9 @@ class DualTest: public Corrade::TestSuite::Tester {
void construct();
void constructDefault();
void compare();
void constructCopy();
void constExpressions();
void compare();
void addSubtract();
void negated();
@ -54,9 +54,9 @@ typedef Math::Dual<Float> Dual;
DualTest::DualTest() {
addTests({&DualTest::construct,
&DualTest::constructDefault,
&DualTest::compare,
&DualTest::constructCopy,
&DualTest::constExpressions,
&DualTest::compare,
&DualTest::addSubtract,
&DualTest::negated,
@ -69,17 +69,26 @@ DualTest::DualTest() {
}
void DualTest::construct() {
Dual a(2.0f, -7.5f);
CORRADE_COMPARE(a.real(), 2.0f);
CORRADE_COMPARE(a.dual(), -7.5f);
Dual b(3.0f);
CORRADE_COMPARE(b.real(), 3.0f);
CORRADE_COMPARE(b.dual(), 0.0f);
constexpr Dual a(2.0f, -7.5f);
constexpr Float b = a.real();
constexpr Float c = a.dual();
CORRADE_COMPARE(b, 2.0f);
CORRADE_COMPARE(c, -7.5f);
constexpr Dual d(3.0f);
CORRADE_COMPARE(d.real(), 3.0f);
CORRADE_COMPARE(d.dual(), 0.0f);
}
void DualTest::constructDefault() {
CORRADE_COMPARE(Dual(), Dual(0.0f, 0.0f));
constexpr Dual a;
CORRADE_COMPARE(a, Dual(0.0f, 0.0f));
}
void DualTest::constructCopy() {
constexpr Dual a(2.0f, 3.0f);
constexpr Dual b(a);
CORRADE_COMPARE(b, Dual(2.0f, 3.0f));
}
void DualTest::compare() {
@ -93,26 +102,6 @@ void DualTest::compare() {
CORRADE_VERIFY(Dual(1.0f, 3.0f) != 1.0f);
}
void DualTest::constExpressions() {
/* Default constructor */
constexpr Dual a;
CORRADE_COMPARE(a, Dual(0.0f, 0.0f));
/* Value constructor */
constexpr Dual b(2.0f, 3.0f);
CORRADE_COMPARE(b, Dual(2.0f, 3.0f));
/* Copy constructor */
constexpr Dual c(b);
CORRADE_COMPARE(c, Dual(2.0f, 3.0f));
/* Data access */
constexpr Float e = b.real();
constexpr Float f = b.dual();
CORRADE_COMPARE(e, 2.0f);
CORRADE_COMPARE(f, 3.0f);
}
void DualTest::addSubtract() {
Dual a(2.0f, -7.5f);
Dual b(-3.3f, 0.2f);

54
src/Math/Test/QuaternionTest.cpp
Unescape View File

@ -37,12 +37,11 @@ class QuaternionTest: public Corrade::TestSuite::Tester {
void construct();
void constructDefault();
void constructFromVector();
void constructCopy();
void compare();
void isNormalized();
void constExpressions();
void addSubtract();
void negated();
void multiplyDivideScalar();
@ -80,12 +79,11 @@ QuaternionTest::QuaternionTest() {
addTests({&QuaternionTest::construct,
&QuaternionTest::constructDefault,
&QuaternionTest::constructFromVector,
&QuaternionTest::constructCopy,
&QuaternionTest::compare,
&QuaternionTest::isNormalized,
&QuaternionTest::constExpressions,
&QuaternionTest::addSubtract,
&QuaternionTest::negated,
&QuaternionTest::multiplyDivideScalar,
@ -112,18 +110,30 @@ QuaternionTest::QuaternionTest() {
}
void QuaternionTest::construct() {
Quaternion q({1.0f, 2.0f, 3.0f}, -4.0f);
CORRADE_COMPARE(q.vector(), Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(q.scalar(), -4.0f);
constexpr Quaternion a({1.0f, 2.0f, 3.0f}, -4.0f);
CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
constexpr Vector3 b = a.vector();
constexpr Float c = a.scalar();
CORRADE_COMPARE(b, Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(c, -4.0f);
}
void QuaternionTest::constructDefault() {
CORRADE_COMPARE(Quaternion(), Quaternion({0.0f, 0.0f, 0.0f}, 1.0f));
CORRADE_COMPARE(Quaternion().length(), 1.0f);
constexpr Quaternion a;
CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 1.0f));
CORRADE_COMPARE(a.length(), 1.0f);
}
void QuaternionTest::constructFromVector() {
CORRADE_COMPARE(Quaternion(Vector3(1.0f, 2.0f, 3.0f)), Quaternion({1.0f, 2.0f, 3.0f}, 0.0f));
constexpr Quaternion a(Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, 0.0f));
}
void QuaternionTest::constructCopy() {
constexpr Quaternion a({1.0f, -3.0f, 7.0f}, 2.5f);
constexpr Quaternion b(a);
CORRADE_COMPARE(b, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f));
}
void QuaternionTest::compare() {
@ -138,30 +148,6 @@ void QuaternionTest::isNormalized() {
CORRADE_VERIFY(Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).isNormalized());
}
void QuaternionTest::constExpressions() {
/* Default constructor */
constexpr Quaternion a;
CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 1.0f));
/* Value constructor */
constexpr Quaternion b({1.0f, -3.0f, 7.0f}, 2.5f);
CORRADE_COMPARE(b, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f));
/* Construct from vector */
constexpr Quaternion c(Vector3(2.0f, -3.0f, 1.5f));
CORRADE_COMPARE(c, Quaternion({2.0f, -3.0f, 1.5f}, 0.0f));
/* Copy constructor */
constexpr Quaternion d(b);
CORRADE_COMPARE(d, Quaternion({1.0f, -3.0f, 7.0f}, 2.5f));
/* Data access */
constexpr Vector3 e = b.vector();
constexpr Float f = b.scalar();
CORRADE_COMPARE(e, Vector3(1.0f, -3.0f, 7.0f));
CORRADE_COMPARE(f, 2.5f);
}
void QuaternionTest::addSubtract() {
Quaternion a({ 1.0f, 3.0f, -2.0f}, -4.0f);
Quaternion b({-0.5f, 1.4f, 3.0f}, 12.0f);

Write Preview
Loading…
Cancel
Save