test/hkl-test-vector.c

   1 #include <math.h>
   2
   3 #include <hkl/hkl-vector.h>
   4 #include <hkl/hkl-matrix.h>
   5
   6 #include "hkl-test.h"
   7
   8 #ifdef HKL_TEST_SUITE_NAME
   9 # undef HKL_TEST_SUITE_NAME
  10 #endif
  11 #define HKL_TEST_SUITE_NAME vector
  12
  13 HKL_TEST_SUITE_FUNC(init)
  14 {
  15         HklVector v;
  16
  17         hkl_vector_init(&v, 1, 2, 3);
  18
  19         HKL_ASSERT_DOUBLES_EQUAL(1., v.data[0], HKL_EPSILON);
  20         HKL_ASSERT_DOUBLES_EQUAL(2., v.data[1], HKL_EPSILON);
  21         HKL_ASSERT_DOUBLES_EQUAL(3., v.data[2], HKL_EPSILON);
  22
  23         return HKL_TEST_PASS;
  24 }
  25
  26 HKL_TEST_SUITE_FUNC(cmp)
  27 {
  28         HklVector v1 = {{0.0, 1.0, 2.0}};
  29         HklVector v2 = {{1.0, 2.0, 3.0}};
  30
  31         HKL_ASSERT_EQUAL(0, hkl_vector_cmp(&v1, &v1));
  32         HKL_ASSERT_EQUAL(1, hkl_vector_cmp(&v1, &v2));
  33
  34         return HKL_TEST_PASS;
  35 }
  36
  37 HKL_TEST_SUITE_FUNC(is_opposite)
  38 {
  39         HklVector v_ref = {{0, 1, 2}};
  40         HklVector v1 = {{1, 2, 3}};
  41         HklVector v2 = {{0, -1, -2}};
  42
  43         HKL_ASSERT_EQUAL(HKL_FALSE, hkl_vector_is_opposite(&v_ref, &v1));
  44         HKL_ASSERT_EQUAL(HKL_TRUE, hkl_vector_is_opposite(&v_ref, &v2));
  45
  46         return HKL_TEST_PASS;
  47 }
  48
  49 HKL_TEST_SUITE_FUNC(norm2)
  50 {
  51         HklVector v1 = {{0.0, 1.0, 2.0}};
  52         HklVector v2 = {{-1.0, 1.0, 2.0}};
  53
  54         HKL_ASSERT_DOUBLES_EQUAL(sqrt(5.0), hkl_vector_norm2(&v1), HKL_EPSILON);
  55         HKL_ASSERT_DOUBLES_EQUAL(sqrt(6.0), hkl_vector_norm2(&v2), HKL_EPSILON);
  56
  57         return HKL_TEST_PASS;
  58 }
  59
  60 HKL_TEST_SUITE_FUNC(normalize)
  61 {
  62         HklVector v_ref = {{1. /sqrt(2.), 1. / sqrt(2.), 0.}};
  63         HklVector v = {{1., 1., 0.}};
  64
  65         hkl_vector_normalize(&v);
  66         HKL_ASSERT_EQUAL(0, hkl_vector_cmp(&v_ref, &v));
  67
  68         return HKL_TEST_PASS;
  69 }
  70
  71 HKL_TEST_SUITE_FUNC(scalar_product)
  72 {
  73         HklVector v = {{0.0, 1.0, 2.0}};
  74
  75         double scalar = hkl_vector_scalar_product(&v, &v);
  76         HKL_ASSERT_DOUBLES_EQUAL( 5.0, scalar, HKL_EPSILON );
  77
  78         return HKL_TEST_PASS;
  79 }
  80
  81 HKL_TEST_SUITE_FUNC(vectorial_product)
  82 {
  83         HklVector v = {{0.0, 1.0, 2.0}};
  84         HklVector v1 = {{1.0, 2.0, 3.0}};
  85         HklVector v_ref = {{-1.0, 2.0, -1.0}};
  86
  87         hkl_vector_vectorial_product(&v, &v1);
  88         HKL_ASSERT_EQUAL(0, hkl_vector_cmp(&v_ref, &v));
  89
  90         return HKL_TEST_PASS;
  91 }
  92
  93 HKL_TEST_SUITE_FUNC(angle)
  94 {
  95         double angle;
  96         HklVector v = {{1., 0., 0.}};
  97         HklVector v1 = {{1., 1., 0.}};
  98         HklVector v2 = {{1., 1., .5}};
  99         HklVector v3 = {{1., .5, -1}};
 100
 101         angle = hkl_vector_angle(&v, &v);
 102         HKL_ASSERT_DOUBLES_EQUAL(0., angle, HKL_EPSILON);
 103
 104         angle = hkl_vector_angle(&v, &v1);
 105         HKL_ASSERT_DOUBLES_EQUAL(acos(1./sqrt(2.)), angle, HKL_EPSILON);
 106
 107         angle = hkl_vector_angle(&v2, &v3);
 108         HKL_ASSERT_DOUBLES_EQUAL(acos(1./2.25), angle, HKL_EPSILON);
 109
 110         return HKL_TEST_PASS;
 111 }
 112
 113 HKL_TEST_SUITE_FUNC(rotated_around_vector)
 114 {
 115         HklVector x = {{1, 0, 0}};
 116         HklVector z = {{0, 0, 1}};
 117         HklVector y_ref = {{0, 1, 0}};
 118
 119         hkl_vector_rotated_around_vector(&x, &z, 90*HKL_DEGTORAD);
 120         HKL_ASSERT_EQUAL(0, hkl_vector_cmp(&y_ref, &x));
 121
 122         return HKL_TEST_PASS;
 123 }
 124
 125 HKL_TEST_SUITE_FUNC(times_smatrix)
 126 {
 127         HklMatrix m = {{{ 1.0, 3.0,-2.0},
 128                 {10.0, 5.0, 5.0},
 129                 {-3.0, 2.0, 0.0}}
 130         };
 131         HklVector v = {{1.0, 2.0, 3.0}};
 132         HklVector v_ref = {{12., 19., 8.}};
 133
 134         hkl_vector_times_smatrix(&v, &m);
 135         HKL_ASSERT_EQUAL(0, hkl_vector_cmp(&v_ref, &v));
 136
 137         return HKL_TEST_PASS;
 138 }
 139
 140 HKL_TEST_SUITE_BEGIN
 141
 142 HKL_TEST( init );
 143 HKL_TEST( cmp );
 144 HKL_TEST( is_opposite );
 145 HKL_TEST( norm2 );
 146 HKL_TEST( normalize );
 147 HKL_TEST( scalar_product );
 148 HKL_TEST( vectorial_product );
 149 HKL_TEST( angle );
 150 HKL_TEST( rotated_around_vector );
 151 HKL_TEST( times_smatrix );
 152
 153 HKL_TEST_SUITE_END