test/unit/test_vec3.cc

   1 /*
   2 Highly Optimized Object-oriented Many-particle Dynamics -- Blue Edition
   3 (HOOMD-blue) Open Source Software License Copyright 2009-2014 The Regents of
   4 the University of Michigan All rights reserved.
   5
   6 HOOMD-blue may contain modifications ("Contributions") provided, and to which
   7 copyright is held, by various Contributors who have granted The Regents of the
   8 University of Michigan the right to modify and/or distribute such Contributions.
   9
  10 You may redistribute, use, and create derivate works of HOOMD-blue, in source
  11 and binary forms, provided you abide by the following conditions:
  12
  13 * Redistributions of source code must retain the above copyright notice, this
  14 list of conditions, and the following disclaimer both in the code and
  15 prominently in any materials provided with the distribution.
  16
  17 * Redistributions in binary form must reproduce the above copyright notice, this
  18 list of conditions, and the following disclaimer in the documentation and/or
  19 other materials provided with the distribution.
  20
  21 * All publications and presentations based on HOOMD-blue, including any reports
  22 or published results obtained, in whole or in part, with HOOMD-blue, will
  23 acknowledge its use according to the terms posted at the time of submission on:
  24 http://codeblue.umich.edu/hoomd-blue/citations.html
  25
  26 * Any electronic documents citing HOOMD-Blue will link to the HOOMD-Blue website:
  27 http://codeblue.umich.edu/hoomd-blue/
  28
  29 * Apart from the above required attributions, neither the name of the copyright
  30 holder nor the names of HOOMD-blue's contributors may be used to endorse or
  31 promote products derived from this software without specific prior written
  32 permission.
  33
  34 Disclaimer
  35
  36 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND
  37 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  38 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR ANY
  39 WARRANTIES THAT THIS SOFTWARE IS FREE OF INFRINGEMENT ARE DISCLAIMED.
  40
  41 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  42 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  43 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  45 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  46 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  47 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48 */
  49
  50 //! Name the unit test module
  51 #define BOOST_TEST_MODULE vec3
  52 #include "boost_utf_configure.h"
  53
  54 #include <iostream>
  55
  56 #include <math.h>
  57
  58 #include <boost/bind.hpp>
  59 #include <boost/python.hpp>
  60 #include <boost/function.hpp>
  61 #include <boost/shared_ptr.hpp>
  62
  63 #include "VectorMath.h"
  64
  65 BOOST_AUTO_TEST_CASE( construction )
  66     {
  67     // test each constructor separately
  68     vec3<Scalar> a;
  69     MY_BOOST_CHECK_SMALL(a.x, tol_small);
  70     MY_BOOST_CHECK_SMALL(a.y, tol_small);
  71     MY_BOOST_CHECK_SMALL(a.z, tol_small);
  72
  73     vec3<Scalar> b(123, 86, -103);
  74     MY_BOOST_CHECK_CLOSE(b.x, 123, tol);
  75     MY_BOOST_CHECK_CLOSE(b.y, 86, tol);
  76     MY_BOOST_CHECK_CLOSE(b.z, -103, tol);
  77
  78     Scalar3 s3 = make_scalar3(-10, 25, 92);
  79     vec3<Scalar> c(s3);
  80     MY_BOOST_CHECK_CLOSE(c.x, s3.x, tol);
  81     MY_BOOST_CHECK_CLOSE(c.y, s3.y, tol);
  82     MY_BOOST_CHECK_CLOSE(c.z, s3.z, tol);
  83
  84     Scalar4 s4 = make_scalar4(18, -22, 78, 12);
  85     vec3<Scalar> d(s4);
  86     MY_BOOST_CHECK_CLOSE(d.x, s4.x, tol);
  87     MY_BOOST_CHECK_CLOSE(d.y, s4.y, tol);
  88     MY_BOOST_CHECK_CLOSE(d.z, s4.z, tol);
  89     }
  90
  91 BOOST_AUTO_TEST_CASE( component_wise )
  92     {
  93     vec3<Scalar> a(1,2,3);
  94     vec3<Scalar> b(4,6,8);
  95     vec3<Scalar> c;
  96
  97     // test each component-wise operator separately
  98     c = a + b;
  99     MY_BOOST_CHECK_CLOSE(c.x, 5, tol);
 100     MY_BOOST_CHECK_CLOSE(c.y, 8, tol);
 101     MY_BOOST_CHECK_CLOSE(c.z, 11, tol);
 102
 103     c = a - b;
 104     MY_BOOST_CHECK_CLOSE(c.x, -3, tol);
 105     MY_BOOST_CHECK_CLOSE(c.y, -4, tol);
 106     MY_BOOST_CHECK_CLOSE(c.z, -5, tol);
 107
 108     c = a * b;
 109     MY_BOOST_CHECK_CLOSE(c.x, 4, tol);
 110     MY_BOOST_CHECK_CLOSE(c.y, 12, tol);
 111     MY_BOOST_CHECK_CLOSE(c.z, 24, tol);
 112
 113     c = a / b;
 114     MY_BOOST_CHECK_CLOSE(c.x, 1.0/4.0, tol);
 115     MY_BOOST_CHECK_CLOSE(c.y, 2.0/6.0, tol);
 116     MY_BOOST_CHECK_CLOSE(c.z, 3.0/8.0, tol);
 117
 118     c = -a;
 119     MY_BOOST_CHECK_CLOSE(c.x, -1, tol);
 120     MY_BOOST_CHECK_CLOSE(c.y, -2, tol);
 121     MY_BOOST_CHECK_CLOSE(c.z, -3, tol);
 122     }
 123
 124 BOOST_AUTO_TEST_CASE( assignment_component_wise )
 125     {
 126     vec3<Scalar> a(1,2,3);
 127     vec3<Scalar> b(4,6,8);
 128     vec3<Scalar> c;
 129
 130     // test each component-wise operator separately
 131     c = a += b;
 132     MY_BOOST_CHECK_CLOSE(c.x, 5, tol);
 133     MY_BOOST_CHECK_CLOSE(c.y, 8, tol);
 134     MY_BOOST_CHECK_CLOSE(c.z, 11, tol);
 135     MY_BOOST_CHECK_CLOSE(a.x, 5, tol);
 136     MY_BOOST_CHECK_CLOSE(a.y, 8, tol);
 137     MY_BOOST_CHECK_CLOSE(a.z, 11, tol);
 138
 139     a = vec3<Scalar>(1,2,3);
 140     c = a -= b;
 141     MY_BOOST_CHECK_CLOSE(c.x, -3, tol);
 142     MY_BOOST_CHECK_CLOSE(c.y, -4, tol);
 143     MY_BOOST_CHECK_CLOSE(c.z, -5, tol);
 144     MY_BOOST_CHECK_CLOSE(a.x, -3, tol);
 145     MY_BOOST_CHECK_CLOSE(a.y, -4, tol);
 146     MY_BOOST_CHECK_CLOSE(a.z, -5, tol);
 147
 148     a = vec3<Scalar>(1,2,3);
 149     c = a *= b;
 150     MY_BOOST_CHECK_CLOSE(c.x, 4, tol);
 151     MY_BOOST_CHECK_CLOSE(c.y, 12, tol);
 152     MY_BOOST_CHECK_CLOSE(c.z, 24, tol);
 153     MY_BOOST_CHECK_CLOSE(a.x, 4, tol);
 154     MY_BOOST_CHECK_CLOSE(a.y, 12, tol);
 155     MY_BOOST_CHECK_CLOSE(a.z, 24, tol);
 156
 157     a = vec3<Scalar>(1,2,3);
 158     c = a /= b;
 159     MY_BOOST_CHECK_CLOSE(c.x, 1.0/4.0, tol);
 160     MY_BOOST_CHECK_CLOSE(c.y, 2.0/6.0, tol);
 161     MY_BOOST_CHECK_CLOSE(c.z, 3.0/8.0, tol);
 162     MY_BOOST_CHECK_CLOSE(a.x, 1.0/4.0, tol);
 163     MY_BOOST_CHECK_CLOSE(a.y, 2.0/6.0, tol);
 164     MY_BOOST_CHECK_CLOSE(a.z, 3.0/8.0, tol);
 165     }
 166
 167 BOOST_AUTO_TEST_CASE( scalar )
 168     {
 169     vec3<Scalar> a(1,2,3);
 170     Scalar b(4);
 171     vec3<Scalar> c;
 172
 173     // test each component-wise operator separately
 174     c = a * b;
 175     MY_BOOST_CHECK_CLOSE(c.x, 4, tol);
 176     MY_BOOST_CHECK_CLOSE(c.y, 8, tol);
 177     MY_BOOST_CHECK_CLOSE(c.z, 12, tol);
 178
 179     c = b * a;
 180     MY_BOOST_CHECK_CLOSE(c.x, 4, tol);
 181     MY_BOOST_CHECK_CLOSE(c.y, 8, tol);
 182     MY_BOOST_CHECK_CLOSE(c.z, 12, tol);
 183
 184     c = a / b;
 185     MY_BOOST_CHECK_CLOSE(c.x, 1.0/4.0, tol);
 186     MY_BOOST_CHECK_CLOSE(c.y, 2.0/4.0, tol);
 187     MY_BOOST_CHECK_CLOSE(c.z, 3.0/4.0, tol);
 188     }
 189
 190 BOOST_AUTO_TEST_CASE( assignment_scalar )
 191     {
 192     vec3<Scalar> a(1,2,3);
 193     Scalar b(4);
 194
 195     // test each component-wise operator separately
 196     a = vec3<Scalar>(1,2,3);
 197     a *= b;
 198     MY_BOOST_CHECK_CLOSE(a.x, 4, tol);
 199     MY_BOOST_CHECK_CLOSE(a.y, 8, tol);
 200     MY_BOOST_CHECK_CLOSE(a.z, 12, tol);
 201
 202     a = vec3<Scalar>(1,2,3);
 203     a /= b;
 204     MY_BOOST_CHECK_CLOSE(a.x, 1.0/4.0, tol);
 205     MY_BOOST_CHECK_CLOSE(a.y, 2.0/4.0, tol);
 206     MY_BOOST_CHECK_CLOSE(a.z, 3.0/4.0, tol);
 207     }
 208
 209 BOOST_AUTO_TEST_CASE( vector_ops )
 210     {
 211     vec3<Scalar> a(1,2,3);
 212     vec3<Scalar> b(6,5,4);
 213     vec3<Scalar> c;
 214     Scalar d;
 215
 216     // test each vector operation
 217     d = dot(a,b);
 218     MY_BOOST_CHECK_CLOSE(d, 28, tol);
 219
 220     c = cross(a,b);
 221     MY_BOOST_CHECK_CLOSE(c.x, -7, tol);
 222     MY_BOOST_CHECK_CLOSE(c.y, 14, tol);
 223     MY_BOOST_CHECK_CLOSE(c.z, -7, tol);
 224     }
 225
 226 BOOST_AUTO_TEST_CASE( vec_to_scalar )
 227     {
 228     vec3<Scalar> a(1,2,3);
 229     Scalar w(4);
 230     Scalar3 m;
 231     Scalar4 n;
 232
 233     // test convenience functions for converting between types
 234     m = vec_to_scalar3(a);
 235     MY_BOOST_CHECK_CLOSE(m.x, 1, tol);
 236     MY_BOOST_CHECK_CLOSE(m.y, 2, tol);
 237     MY_BOOST_CHECK_CLOSE(m.z, 3, tol);
 238
 239     n = vec_to_scalar4(a, w);
 240     MY_BOOST_CHECK_CLOSE(n.x, 1, tol);
 241     MY_BOOST_CHECK_CLOSE(n.y, 2, tol);
 242     MY_BOOST_CHECK_CLOSE(n.z, 3, tol);
 243     MY_BOOST_CHECK_CLOSE(n.w, 4, tol);
 244
 245     // test mapping of Scalar{3,4} to vec3
 246     a = vec3<Scalar>(0.0, 0.0, 0.0);
 247     a = vec3<Scalar>(m);
 248     MY_BOOST_CHECK_CLOSE(a.x, 1.0, tol);
 249     MY_BOOST_CHECK_CLOSE(a.y, 2.0, tol);
 250     MY_BOOST_CHECK_CLOSE(a.z, 3.0, tol);
 251
 252     a = vec3<Scalar>(0.0, 0.0, 0.0);
 253     a = vec3<Scalar>(n);
 254     MY_BOOST_CHECK_CLOSE(a.x, 1.0, tol);
 255     MY_BOOST_CHECK_CLOSE(a.y, 2.0, tol);
 256     MY_BOOST_CHECK_CLOSE(a.z, 3.0, tol);
 257     }
 258
 259 BOOST_AUTO_TEST_CASE( comparison )
 260     {
 261     vec3<Scalar> a(1.1,2.1,.1);
 262     vec3<Scalar> b = a;
 263     vec3<Scalar> c(.1,1.1,2.1);
 264
 265     // test equality
 266     BOOST_CHECK(a==b);
 267     BOOST_CHECK(!(a==c));
 268
 269     // test inequality
 270     BOOST_CHECK(!(a!=b));
 271     BOOST_CHECK(a!=c);
 272     }
 273
 274 BOOST_AUTO_TEST_CASE( test_swap )
 275     {
 276     vec3<Scalar> a(1.1, 2.2, 0.0);
 277     vec3<Scalar> b(3.3, 4.4, 0.0);
 278     vec3<Scalar> c(1.1, 2.2, 0.0);
 279     vec3<Scalar> d(3.3, 4.4, 0.0);
 280
 281     // test swap
 282     swap(a, b);
 283     BOOST_CHECK(a==d);
 284     BOOST_CHECK(b==c);
 285     }