src/gromacs/math/tests/vectypes.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2014,2015,2016,2018,2019, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Tests various corners of gmx::RVec implementation.
  38  *
  39  * The main point of these tests is to check that all different constructs
  40  * using gmx::RVec compile, and that some of the non-trivial conversions
  41  * to/from rvec work as intended.
  42  *
  43  * \author Teemu Murtola <teemu.murtola@gmail.com>
  44  * \ingroup module_math
  45  */
  46 #include "gmxpre.h"
  47
  48 #include "gromacs/math/vectypes.h"
  49
  50 #include <vector>
  51
  52 #include <gtest/gtest.h>
  53
  54 #include "gromacs/math/vec.h"
  55
  56 #include "testutils/testasserts.h"
  57
  58 namespace
  59 {
  60
  61 using gmx::RVec;
  62 using gmx::DVec;
  63 using gmx::IVec;
  64
  65 TEST(RVecTest, CanBeStoredInVector)
  66 {
  67     std::vector<RVec> v;
  68     v.emplace_back(1, 2, 3);
  69     v.resize(2);
  70     EXPECT_EQ(1, v[0][XX]);
  71     EXPECT_EQ(2, v[0][YY]);
  72     EXPECT_EQ(3, v[0][ZZ]);
  73 }
  74
  75 TEST(RVecTest, ConvertsImplicitlyFrom_rvec)
  76 {
  77     std::vector<RVec> v;
  78     rvec              x = { 1, 2, 3 };
  79     v.emplace_back(x);
  80     EXPECT_EQ(1, v[0][XX]);
  81     EXPECT_EQ(2, v[0][YY]);
  82     EXPECT_EQ(3, v[0][ZZ]);
  83 }
  84
  85 TEST(RVecTest, ConvertsImplicitlyTo_rvec)
  86 {
  87     std::vector<RVec> v;
  88     v.emplace_back(1, 2, 3);
  89     rvec              x;
  90     copy_rvec(v[0], x);
  91     EXPECT_EQ(1, x[XX]);
  92     EXPECT_EQ(2, x[YY]);
  93     EXPECT_EQ(3, x[ZZ]);
  94 }
  95
  96 TEST(RVecTest, WorksAsMutable_rvec)
  97 {
  98     std::vector<RVec> v;
  99     v.emplace_back(1, 2, 3);
 100     rvec              x = {2, 3, 4};
 101     copy_rvec(x, v[0]);
 102     EXPECT_EQ(2, v[0][XX]);
 103     EXPECT_EQ(3, v[0][YY]);
 104     EXPECT_EQ(4, v[0][ZZ]);
 105 }
 106
 107 TEST(RVecTest, WorksAs_rvec_Array)
 108 {
 109     std::vector<RVec> v;
 110     v.emplace_back(1, 2, 3);
 111     v.emplace_back(2, 3, 4);
 112     const rvec *r = as_rvec_array(v.data());
 113     EXPECT_EQ(1, r[0][XX]);
 114     EXPECT_EQ(2, r[0][YY]);
 115     EXPECT_EQ(3, r[0][ZZ]);
 116     EXPECT_EQ(2, r[1][XX]);
 117     EXPECT_EQ(3, r[1][YY]);
 118     EXPECT_EQ(4, r[1][ZZ]);
 119 }
 120
 121 /*! \brief
 122  * Test overloaded math operations
 123  */
 124
 125 TEST(RVecTest, CanAddRVecToRvec)
 126 {
 127     RVec a(1, 2, 3);
 128     RVec b(3, 2, 1);
 129     RVec c;
 130     c = a + b;
 131     EXPECT_EQ(4, c[XX]);
 132     EXPECT_EQ(4, c[YY]);
 133     EXPECT_EQ(4, c[ZZ]);
 134 }
 135
 136 TEST(RVecTest, CanAddAssignRVecToRvec)
 137 {
 138     RVec a(1, 2, 3);
 139     RVec b(3, 2, 1);
 140     a += b;
 141     EXPECT_EQ(4, a[XX]);
 142     EXPECT_EQ(4, a[YY]);
 143     EXPECT_EQ(4, a[ZZ]);
 144 }
 145
 146
 147 TEST(RVecTest, CanSubtractRVecFromRvec)
 148 {
 149     RVec a(1, 2, 3);
 150     RVec b(3, 2, 1);
 151     RVec c;
 152     c = b - a;
 153     EXPECT_EQ(2, c[XX]);
 154     EXPECT_EQ(0, c[YY]);
 155     EXPECT_EQ(-2, c[ZZ]);
 156 }
 157
 158 TEST(RVecTest, CanSubtractAssignRVecFromRvec)
 159 {
 160     RVec a(1, 2, 3);
 161     RVec b(3, 2, 1);
 162     RVec c;
 163     b -= a;
 164     EXPECT_EQ(2, b[XX]);
 165     EXPECT_EQ(0, b[YY]);
 166     EXPECT_EQ(-2, b[ZZ]);
 167 }
 168
 169 TEST(RVecTest, CanDotProductRVecByRvec)
 170 {
 171     RVec  a(1, 2, 3);
 172     RVec  b(3, 2, 1);
 173     float c;
 174     c = a.dot(b);
 175     EXPECT_EQ(10, c);
 176 }
 177
 178 TEST(RVecTest, CanCrossProductRVecByRvec)
 179 {
 180     RVec a(1, 2, 3);
 181     RVec b(3, 2, 1);
 182     RVec c;
 183     c = a.cross(b);
 184     EXPECT_EQ(-4, c[XX]);
 185     EXPECT_EQ(8, c[YY]);
 186     EXPECT_EQ(-4, c[ZZ]);
 187 }
 188
 189 /*! \brief
 190  * Test for inplace operations imported from vec.h
 191  */
 192
 193 TEST(RVecTest, CanDivideRVecInplace)
 194 {
 195     RVec a(1, 2, 3);
 196     real b = 0.5;
 197     RVec c;
 198     c = a/b;
 199     EXPECT_EQ(2, c[XX]);
 200     EXPECT_EQ(4, c[YY]);
 201     EXPECT_EQ(6, c[ZZ]);
 202 }
 203
 204 TEST(RVecTest, CanScaleRVec)
 205 {
 206     RVec a(1, 2, 3);
 207     real b = 2.0;
 208     a *= b;
 209     EXPECT_EQ(2, a[XX]);
 210     EXPECT_EQ(4, a[YY]);
 211     EXPECT_EQ(6, a[ZZ]);
 212 }
 213
 214 TEST(RVecTest, CanDivideRVec)
 215 {
 216     RVec a(1, 2, 3);
 217     real b = 0.5;
 218     a /= b;
 219     EXPECT_EQ(2, a[XX]);
 220     EXPECT_EQ(4, a[YY]);
 221     EXPECT_EQ(6, a[ZZ]);
 222 }
 223
 224 TEST(RVecTest, CanDoUnitvFromRVec)
 225 {
 226     RVec a(3, 0, 0);
 227     RVec b;
 228     b = a.unitVector();
 229     EXPECT_REAL_EQ(1, b[XX]);
 230     EXPECT_REAL_EQ(0, b[YY]);
 231     EXPECT_REAL_EQ(0, b[ZZ]);
 232 }
 233
 234 TEST(RVecTest, CanSqLengthOfRVec)
 235 {
 236     RVec a(1, 2, 2);
 237     real b;
 238     b = a.norm2();
 239     EXPECT_REAL_EQ(9, b);
 240 }
 241
 242 TEST(RVecTest, CanLengthOfRVec)
 243 {
 244     RVec a(1, 2, 2);
 245     real b;
 246     b = a.norm();
 247     EXPECT_REAL_EQ(3, b);
 248 }
 249
 250 TEST(RVecTest, CanCastToRVec)
 251 {
 252     DVec a(1, 2, 2);
 253     RVec b;
 254     b = a.toRVec();
 255     EXPECT_EQ(1, b[XX]);
 256     EXPECT_EQ(2, b[YY]);
 257     EXPECT_EQ(2, b[ZZ]);
 258 }
 259
 260 TEST(RVecTest, CanCastToDVec)
 261 {
 262     RVec a(1, 2, 2);
 263     DVec b;
 264     b = a.toDVec();
 265     EXPECT_EQ(1, b[XX]);
 266     EXPECT_EQ(2, b[YY]);
 267     EXPECT_EQ(2, b[ZZ]);
 268 }
 269
 270
 271 /*! \brief
 272  * Tests for out of class functions
 273  */
 274 TEST(RVecTest, CanLeftScalarMultiply)
 275 {
 276     RVec a(1, 2, 3);
 277     real b = 2.0;
 278     RVec c;
 279     c = b*a;
 280     EXPECT_EQ(2, c[XX]);
 281     EXPECT_EQ(4, c[YY]);
 282     EXPECT_EQ(6, c[ZZ]);
 283 }
 284
 285 TEST(RVecTest, CanRightScalarMultiply)
 286 {
 287     RVec a(1, 2, 3);
 288     real b = 2.0;
 289     RVec c;
 290     c = a*b;
 291     EXPECT_EQ(2, c[XX]);
 292     EXPECT_EQ(4, c[YY]);
 293     EXPECT_EQ(6, c[ZZ]);
 294 }
 295
 296 TEST(RVecTest, CanGetUnitvFromRVec)
 297 {
 298     RVec a(3, 0, 0);
 299     RVec b;
 300     b = gmx::unitVector(a);
 301     EXPECT_REAL_EQ(1, b[XX]);
 302     EXPECT_REAL_EQ(0, b[YY]);
 303     EXPECT_REAL_EQ(0, b[ZZ]);
 304 }
 305
 306 TEST(RVecTest, CanGetSqLengthOfRVec)
 307 {
 308     RVec a(1, 2, 2);
 309     real b;
 310     b = gmx::norm2(a);
 311     EXPECT_REAL_EQ(9, b);
 312 }
 313
 314 TEST(RVecTest, CanGetLengthOfRVec)
 315 {
 316     RVec a(1, 2, 2);
 317     real b;
 318     b = gmx::norm(a);
 319     EXPECT_REAL_EQ(3, b);
 320 }
 321
 322 TEST(RVecTest, CanDoCrossProductOfRVec)
 323 {
 324     RVec a(1, 2, 3);
 325     RVec b(3, 2, 1);
 326     RVec c;
 327     c = gmx::cross(a, b);
 328     EXPECT_EQ(-4, c[XX]);
 329     EXPECT_EQ(8, c[YY]);
 330     EXPECT_EQ(-4, c[ZZ]);
 331 }
 332
 333 TEST(RVecTest, CanDoDotProductOfRVec)
 334 {
 335     RVec  a(1, 2, 3);
 336     RVec  b(3, 2, 1);
 337     float c;
 338     c = gmx::dot(a, b);
 339     EXPECT_EQ(10, c);
 340 }
 341
 342 TEST(RVecTest, CanScaleByVector)
 343 {
 344     RVec a(1, 2, 3);
 345     RVec b(3, 2, 1);
 346     RVec scaled = scaleByVector(a, b);
 347     EXPECT_REAL_EQ(3, scaled[XX]);
 348     EXPECT_REAL_EQ(4, scaled[YY]);
 349     EXPECT_REAL_EQ(3, scaled[ZZ]);
 350 }
 351
 352 TEST(RVecTest, asIVec)
 353 {
 354     RVec a(1.2, 2.7, -3e3);
 355     auto asIvec = a.toIVec();
 356
 357     EXPECT_REAL_EQ(1, asIvec[XX]);
 358     EXPECT_REAL_EQ(2, asIvec[YY]);
 359     EXPECT_REAL_EQ(-3000, asIvec[ZZ]);
 360 }
 361
 362 TEST(RVecTest, elementWiseMin)
 363 {
 364     RVec a(1, 2, 3);
 365     RVec b(3, 2, 1);
 366     auto minAB = elementWiseMin(a, b);
 367
 368     EXPECT_REAL_EQ(1, minAB[XX]);
 369     EXPECT_REAL_EQ(2, minAB[YY]);
 370     EXPECT_REAL_EQ(1, minAB[ZZ]);
 371 }
 372
 373 TEST(RVecTest, elementWiseMax)
 374 {
 375     RVec a(1, 2, 3);
 376     RVec b(3, 2, 1);
 377     auto maxAB = elementWiseMax(a, b);
 378
 379     EXPECT_REAL_EQ(3, maxAB[XX]);
 380     EXPECT_REAL_EQ(2, maxAB[YY]);
 381     EXPECT_REAL_EQ(3, maxAB[ZZ]);
 382 }
 383
 384 /*! \brief
 385  * Helper function for testing DVec to dvec conversions.
 386  */
 387 const dvec *testFunction(const dvec &x)
 388 {
 389     return &x;
 390 }
 391
 392 TEST(RVecTest, WorksAs_dvec_Reference)
 393 {
 394     DVec        v(1, 2, 3);
 395     const dvec *r = testFunction(v.as_vec());
 396     EXPECT_EQ(1, r[0][XX]);
 397     EXPECT_EQ(2, r[0][YY]);
 398     EXPECT_EQ(3, r[0][ZZ]);
 399 }
 400
 401 /*! \brief
 402  * Helper function for testing IVec to ivec conversions.
 403  */
 404 const ivec *testFunction(const ivec &x)
 405 {
 406     return &x;
 407 }
 408
 409 TEST(RVecTest, WorksAs_ivec_Reference)
 410 {
 411     IVec        v(1, 2, 3);
 412     const ivec *r = testFunction(v.as_vec());
 413     EXPECT_EQ(1, r[0][XX]);
 414     EXPECT_EQ(2, r[0][YY]);
 415     EXPECT_EQ(3, r[0][ZZ]);
 416 }
 417
 418 /*! \brief
 419  * Helper function for testing RVec to rvec conversions.
 420  */
 421 #if !GMX_DOUBLE //otherwise rvec==dvec
 422 const rvec *testFunction(const rvec &x)
 423 {
 424     return &x;
 425 }
 426 #endif
 427
 428 TEST(RVecTest, WorksAs_rvec_Reference)
 429 {
 430     RVec        v(1, 2, 3);
 431     const rvec *r = testFunction(v);
 432     EXPECT_EQ(1, r[0][XX]);
 433     EXPECT_EQ(2, r[0][YY]);
 434     EXPECT_EQ(3, r[0][ZZ]);
 435 }
 436
 437 TEST(RVecTest, CopyConstructorWorks)
 438 {
 439     RVec v(1, 2, 3);
 440     RVec copy(v);
 441     EXPECT_EQ(1, copy[XX]);
 442     EXPECT_EQ(2, copy[YY]);
 443     EXPECT_EQ(3, copy[ZZ]);
 444 }
 445
 446 TEST(RVecTest, CopyAssignmentWorks)
 447 {
 448     RVec v(1, 2, 3);
 449     RVec copy;
 450     copy = v;
 451     EXPECT_EQ(1, copy[XX]);
 452     EXPECT_EQ(2, copy[YY]);
 453     EXPECT_EQ(3, copy[ZZ]);
 454 }
 455
 456 TEST(RVecTest, MoveConstructorWorks)
 457 {
 458     RVec v(1, 2, 3);
 459     RVec copy(v);
 460     EXPECT_EQ(1, copy[XX]);
 461     EXPECT_EQ(2, copy[YY]);
 462     EXPECT_EQ(3, copy[ZZ]);
 463 }
 464
 465 TEST(RVecTest, MoveAssignmentWorks)
 466 {
 467     RVec v(1, 2, 3);
 468     RVec copy;
 469     copy = v;
 470     EXPECT_EQ(1, copy[XX]);
 471     EXPECT_EQ(2, copy[YY]);
 472     EXPECT_EQ(3, copy[ZZ]);
 473 }
 474
 475 } // namespace