tests/vector.cpp

   1 #include <limits>
   2 #include <msp/linal/vector.h>
   3 #include <msp/test/test.h>
   4
   5 using namespace std;
   6 using namespace Msp;
   7
   8 class VectorTests: public Test::RegisteredTest<VectorTests>
   9 {
  10 private:
  11         typedef LinAl::Vector<int, 2> Vector2i;
  12         typedef LinAl::Vector<int, 3> Vector3i;
  13         typedef LinAl::Vector<float, 3> Vector3f;
  14
  15 public:
  16         VectorTests();
  17
  18         static const char *get_name() { return "Vector"; }
  19
  20 private:
  21         void constructors();
  22         void component_aliases();
  23         void composition();
  24         void slice();
  25         void addition();
  26         void inner_prod();
  27         void cross_prod();
  28         void norm();
  29         void unit_vec();
  30 };
  31
  32 VectorTests::VectorTests()
  33 {
  34         add(&VectorTests::constructors, "Constructors");
  35         add(&VectorTests::component_aliases, "Component aliases");
  36         add(&VectorTests::composition, "Compose");
  37         add(&VectorTests::slice, "Slice");
  38         add(&VectorTests::addition, "Addition");
  39         add(&VectorTests::inner_prod, "Inner product");
  40         add(&VectorTests::cross_prod, "Cross product");
  41         add(&VectorTests::norm, "Norm");
  42         add(&VectorTests::unit_vec, "Normalize");
  43 }
  44
  45 void VectorTests::constructors()
  46 {
  47         static int data[] = { 1, 2, 3 };
  48
  49         Vector2i v1(1, 2);
  50         EXPECT_EQUAL(v1[0], 1);
  51         EXPECT_EQUAL(v1[1], 2);
  52
  53         Vector3i v2(data);
  54         EXPECT_EQUAL(v2[0], 1);
  55         EXPECT_EQUAL(v2[1], 2);
  56         EXPECT_EQUAL(v2[2], 3);
  57
  58 #if __cplusplus >= 201103L
  59         LinAl::Vector<int, 1> v3(1);
  60         EXPECT_EQUAL(v3[0], 1);
  61
  62         LinAl::Vector<int, 5> v4(1, 2, 3, 4, 5);
  63         EXPECT_EQUAL(v4[0], 1);
  64         EXPECT_EQUAL(v4[4], 5);
  65 #endif
  66 }
  67
  68 void VectorTests::component_aliases()
  69 {
  70         Vector3i v;
  71         v.x = 1;
  72         v[1] = 2;
  73         v.z = 3;
  74         EXPECT_EQUAL(v.x, v[0]);
  75         EXPECT_EQUAL(v.y, v[1]);
  76         EXPECT_EQUAL(v.z, v[2]);
  77 }
  78
  79 void VectorTests::composition()
  80 {
  81         Vector2i v(1, 2);
  82         EXPECT_EQUAL(compose(3, v), Vector3i(3, 1, 2));
  83         EXPECT_EQUAL(compose(v, 3), Vector3i(1, 2, 3));
  84 }
  85
  86 void VectorTests::slice()
  87 {
  88         Vector3i v(1, 2, 3);
  89         EXPECT_EQUAL(v.slice<2>(0), Vector2i(1, 2));
  90         EXPECT_EQUAL(v.slice<2>(1), Vector2i(2, 3));
  91         EXPECT_EQUAL(v.slice<3>(0), v);
  92 }
  93
  94 void VectorTests::addition()
  95 {
  96         Vector3i v(1, 2, 3);
  97         Vector3i w(4, 3, 5);
  98         EXPECT_EQUAL(v+w, Vector3i(5, 5, 8));
  99         EXPECT_EQUAL(v+w, w+v);
 100 }
 101
 102 void VectorTests::inner_prod()
 103 {
 104         Vector3i v(1, 2, 3);
 105         Vector3i w(-2, 5, 1);
 106         Vector3i u(-13, -7, 9);
 107         EXPECT_EQUAL(inner_product(v, w), 11);
 108         EXPECT_EQUAL(inner_product(v, u), 0);
 109         EXPECT_EQUAL(inner_product(w, u), 0);
 110 }
 111
 112 void VectorTests::cross_prod()
 113 {
 114         Vector3i x(1, 0, 0);
 115         Vector3i y(0, 1, 0);
 116         Vector3i z(0, 0, 1);
 117         EXPECT_EQUAL(cross(x, y), z);
 118         EXPECT_EQUAL(cross(y, x), -z);
 119         EXPECT_EQUAL(cross(y, z), x);
 120         EXPECT_EQUAL(cross(z, y), -x);
 121         EXPECT_EQUAL(cross(z, x), y);
 122         EXPECT_EQUAL(cross(x, z), -y);
 123 }
 124
 125 void VectorTests::norm()
 126 {
 127         Vector3f v(2.0f, 6.0f, 9.0f);
 128         Vector3f w(-3.0f, -4.0f, 12.0f);
 129         EXPECT_EQUAL(v.norm(), 11.0f);
 130         EXPECT_EQUAL(w.norm(), 13.0f);
 131 }
 132
 133 template<typename T, unsigned N>
 134 bool is_unit(const LinAl::Vector<T, N> &v)
 135 {
 136         static const T limit = numeric_limits<T>::epsilon()*4;
 137         return abs(v.norm()-T(1))<=limit;
 138 }
 139
 140 void VectorTests::unit_vec()
 141 {
 142         Vector3f v(2.0f, 6.0f, 9.0f);
 143         Vector3f w(-3.0f, -4.0f, 12.0f);
 144         EXPECT(is_unit(normalize(v)));
 145         EXPECT(is_unit(normalize(w)));
 146 }