Simbody  3.8
Testing.h
Go to the documentation of this file.
1 #ifndef SimTK_SimTKCOMMON_TESTING_H_
2 #define SimTK_SimTKCOMMON_TESTING_H_
3 
4 /* -------------------------------------------------------------------------- *
5  * Simbody(tm): SimTKcommon *
6  * -------------------------------------------------------------------------- *
7  * This is part of the SimTK biosimulation toolkit originating from *
8  * Simbios, the NIH National Center for Physics-Based Simulation of *
9  * Biological Structures at Stanford, funded under the NIH Roadmap for *
10  * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11  * *
12  * Portions copyright (c) 2009-15 Stanford University and the Authors. *
13  * Authors: Michael Sherman *
14  * Contributors: *
15  * *
16  * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17  * not use this file except in compliance with the License. You may obtain a *
18  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19  * *
20  * Unless required by applicable law or agreed to in writing, software *
21  * distributed under the License is distributed on an "AS IS" BASIS, *
22  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23  * See the License for the specific language governing permissions and *
24  * limitations under the License. *
25  * -------------------------------------------------------------------------- */
26 
27 #include "SimTKcommon/basics.h"
28 #include "SimTKcommon/Simmatrix.h"
31 
32 #include <cmath>
33 #include <algorithm>
34 #include <iostream>
35 
41 namespace SimTK {
42 
163 class Test {
164 public:
165  class Subtest;
166  Test(const std::string& name)
167  : startCpuTime(SimTK::cpuTime()),
168  startRealTime(SimTK::realTime()),
169  testName(name)
170  {
171  std::clog << "Starting test " << testName << " ...\n";
172  }
173  ~Test() {
174  const double finalRealTime=SimTK::realTime();
175  const double finalCpuTime=SimTK::cpuTime();
176  std::ostringstream fmt;
177  fmt << std::fixed << std::setprecision(1);
178  fmt << "\n" << testName << " done."
179  << " real/CPU ms: " << (finalRealTime-startRealTime)*1000
180  << " / " << (finalCpuTime-startCpuTime)*1000 <<std::endl;
181  std::clog << fmt.str();
182  }
183 
184  template <class T>
185  static double defTol() {return (double)NTraits<typename CNT<T>::Precision>::getSignificant();}
186 
187  // For dissimilar types, the default tolerance is the narrowest of the two.
188  template <class T1, class T2>
189  static double defTol2() {return std::max(defTol<T1>(), defTol<T2>());}
190 
191  // Scale by the magnitude of the quantities being compared, so that we don't
192  // ask for unreasonable precision. For magnitudes near zero, we'll be satisfied
193  // if both are very small without demanding that they must also be relatively
194  // close. That is, we use a relative tolerance for big numbers and an absolute
195  // tolerance for small ones.
196  static bool numericallyEqual(float v1, float v2, int n, double tol=defTol<float>()) {
197  const float scale = n*std::max(std::max(std::abs(v1), std::abs(v2)), 1.0f);
198  return std::abs(v1-v2) < scale*(float)tol;
199  }
200  static bool numericallyEqual(double v1, double v2, int n, double tol=defTol<double>()) {
201  const double scale = n*std::max(std::max(std::abs(v1), std::abs(v2)), 1.0);
202  return std::abs(v1-v2) < scale*(double)tol;
203  }
204 
205  // For integers we ignore tolerance.
206  static bool numericallyEqual(int i1, int i2, int n, double tol=0) {return i1==i2;}
207  static bool numericallyEqual(unsigned u1, unsigned u2, int n, double tol=0) {return u1==u2;}
208 
209  // Mixed floating types use default tolerance for the narrower type.
210  static bool numericallyEqual(float v1, double v2, int n, double tol=defTol<float>())
211  { return numericallyEqual((double)v1, v2, n, tol); }
212  static bool numericallyEqual(double v1, float v2, int n, double tol=defTol<float>())
213  { return numericallyEqual(v1, (double)v2, n, tol); }
214 
215  // Mixed int/floating just upgrades int to floating type.
216  static bool numericallyEqual(int i1, float f2, int n, double tol=defTol<float>())
217  { return numericallyEqual((float)i1,f2,n,tol); }
218  static bool numericallyEqual(float f1, int i2, int n, double tol=defTol<float>())
219  { return numericallyEqual(f1,(float)i2,n,tol); }
220  static bool numericallyEqual(unsigned i1, float f2, int n, double tol=defTol<float>())
221  { return numericallyEqual((float)i1,f2,n,tol); }
222  static bool numericallyEqual(float f1, unsigned i2, int n, double tol=defTol<float>())
223  { return numericallyEqual(f1,(float)i2,n,tol); }
224  static bool numericallyEqual(int i1, double f2, int n, double tol=defTol<double>())
225  { return numericallyEqual((double)i1,f2,n,tol); }
226  static bool numericallyEqual(double f1, int i2, int n, double tol=defTol<double>())
227  { return numericallyEqual(f1,(double)i2,n,tol); }
228  static bool numericallyEqual(unsigned i1, double f2, int n, double tol=defTol<double>())
229  { return numericallyEqual((double)i1,f2,n,tol); }
230  static bool numericallyEqual(double f1, unsigned i2, int n, double tol=defTol<double>())
231  { return numericallyEqual(f1,(double)i2,n,tol); }
232 
233  template <class P>
234  static bool numericallyEqual(const std::complex<P>& v1, const std::complex<P>& v2, int n, double tol=defTol<P>()) {
235  return numericallyEqual(v1.real(), v2.real(), n, tol)
236  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
237  }
238  template <class P>
239  static bool numericallyEqual(const conjugate<P>& v1, const conjugate<P>& v2, int n, double tol=defTol<P>()) {
240  return numericallyEqual(v1.real(), v2.real(), n, tol)
241  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
242  }
243  template <class P>
244  static bool numericallyEqual(const std::complex<P>& v1, const conjugate<P>& v2, int n, double tol=defTol<P>()) {
245  return numericallyEqual(v1.real(), v2.real(), n, tol)
246  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
247  }
248  template <class P>
249  static bool numericallyEqual(const conjugate<P>& v1, const std::complex<P>& v2, int n, double tol=defTol<P>()) {
250  return numericallyEqual(v1.real(), v2.real(), n, tol)
251  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
252  }
253  template <class P>
254  static bool numericallyEqual(const negator<P>& v1, const negator<P>& v2, int n, double tol=defTol<P>()) {
255  return numericallyEqual(-v1, -v2, n, tol); // P, P
256  }
257  template <class P>
258  static bool numericallyEqual(const P& v1, const negator<P>& v2, int n, double tol=defTol<P>()) {
259  return numericallyEqual(-v1, -v2, n, tol); // P, P
260  }
261  template <class P>
262  static bool numericallyEqual(const negator<P>& v1, const P& v2, int n, double tol=defTol<P>()) {
263  return numericallyEqual(-v1, -v2, n, tol); // P, P
264  }
265  template <class P>
266  static bool numericallyEqual(const negator<std::complex<P> >& v1, const conjugate<P>& v2, int n, double tol=defTol<P>()) {
267  return numericallyEqual(-v1, -v2, n, tol); // complex, conjugate
268  }
269  template <class P>
270  static bool numericallyEqual(const negator<conjugate<P> >& v1, const std::complex<P>& v2, int n, double tol=defTol<P>()) {
271  return numericallyEqual(-v1, -v2, n, tol); // conjugate, complex
272  }
273  template <class P>
274  static bool numericallyEqual(const std::complex<P>& v1, const negator<conjugate<P> >& v2, int n, double tol=defTol<P>()) {
275  return numericallyEqual(-v1, -v2, n, tol); // complex, conjugate
276  }
277  template <class P>
278  static bool numericallyEqual(const conjugate<P>& v1, const negator<std::complex<P> >& v2, int n, double tol=defTol<P>()) {
279  return numericallyEqual(-v1, -v2, n, tol); // conjugate, complex
280  }
281  template <int M, class E1, int S1, class E2, int S2>
282  static bool numericallyEqual(const Vec<M,E1,S1>& v1, const Vec<M,E2,S2>& v2, int n, double tol=(defTol2<E1,E2>())) {
283  for (int i=0; i<M; ++i) if (!numericallyEqual(v1[i],v2[i], n, tol)) return false;
284  return true;
285  }
286  template <int N, class E1, int S1, class E2, int S2>
287  static bool numericallyEqual(const Row<N,E1,S1>& v1, const Row<N,E2,S2>& v2, int n, double tol=(defTol2<E1,E2>())) {
288  for (int j=0; j<N; ++j) if (!numericallyEqual(v1[j],v2[j], n, tol)) return false;
289  return true;
290  }
291  template <int M, int N, class E1, int CS1, int RS1, class E2, int CS2, int RS2>
292  static bool numericallyEqual(const Mat<M,N,E1,CS1,RS1>& v1, const Mat<M,N,E2,CS2,RS2>& v2, int n, double tol=(defTol2<E1,E2>())) {
293  for (int j=0; j<N; ++j) if (!numericallyEqual(v1(j),v2(j), n, tol)) return false;
294  return true;
295  }
296  template <int N, class E1, int S1, class E2, int S2>
297  static bool numericallyEqual(const SymMat<N,E1,S1>& v1, const SymMat<N,E2,S2>& v2, int n, double tol=(defTol2<E1,E2>())) {
298  return numericallyEqual(v1.getAsVec(), v2.getAsVec(), n, tol);
299  }
300  template <class E1, class E2>
301  static bool numericallyEqual(const VectorView_<E1>& v1, const VectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>())) {
302  if (v1.size() != v2.size()) return false;
303  for (int i=0; i < v1.size(); ++i)
304  if (!numericallyEqual(v1[i], v2[i], n, tol)) return false;
305  return true;
306  }
307  template <class E1, class E2>
308  static bool numericallyEqual(const Vector_<E1>& v1, const Vector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
309  { return numericallyEqual((const VectorView_<E1>&)v1, (const VectorView_<E2>&)v2, n, tol); }
310  template <class E1, class E2>
311  static bool numericallyEqual(const Vector_<E1>& v1, const VectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
312  { return numericallyEqual((const VectorView_<E1>&)v1, (const VectorView_<E2>&)v2, n, tol); }
313  template <class E1, class E2>
314  static bool numericallyEqual(const VectorView_<E1>& v1, const Vector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
315  { return numericallyEqual((const VectorView_<E1>&)v1, (const VectorView_<E2>&)v2, n, tol); }
316 
317  template <class E1, class E2>
318  static bool numericallyEqual(const RowVectorView_<E1>& v1, const RowVectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>())) {
319  if (v1.size() != v2.size()) return false;
320  for (int i=0; i < v1.size(); ++i)
321  if (!numericallyEqual(v1[i], v2[i], n, tol)) return false;
322  return true;
323  }
324  template <class E1, class E2>
325  static bool numericallyEqual(const RowVector_<E1>& v1, const RowVector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
326  { return numericallyEqual((const RowVectorView_<E1>&)v1, (const RowVectorView_<E2>&)v2, n, tol); }
327  template <class E1, class E2>
328  static bool numericallyEqual(const RowVector_<E1>& v1, const RowVectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
329  { return numericallyEqual((const RowVectorView_<E1>&)v1, (const RowVectorView_<E2>&)v2, n, tol); }
330  template <class E1, class E2>
331  static bool numericallyEqual(const RowVectorView_<E1>& v1, const RowVector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
332  { return numericallyEqual((const RowVectorView_<E1>&)v1, (const RowVectorView_<E2>&)v2, n, tol); }
333 
334  template <class E1, class E2>
335  static bool numericallyEqual(const MatrixView_<E1>& v1, const MatrixView_<E2>& v2, int n, double tol=(defTol2<E1,E2>())) {
336  if (v1.nrow() != v2.nrow() || v1.ncol() != v2.ncol()) return false;
337  for (int j=0; j < v1.ncol(); ++j)
338  if (!numericallyEqual(v1(j), v2(j), n, tol)) return false;
339  return true;
340  }
341  template <class E1, class E2>
342  static bool numericallyEqual(const Matrix_<E1>& m1, const Matrix_<E2>& m2, int n, double tol=(defTol2<E1,E2>()))
343  { return numericallyEqual((const MatrixView_<E1>&)m1, (const MatrixView_<E2>&)m2, n, tol); }
344  template <class E1, class E2>
345  static bool numericallyEqual(const Matrix_<E1>& m1, const MatrixView_<E2>& m2, int n, double tol=(defTol2<E1,E2>()))
346  { return numericallyEqual((const MatrixView_<E1>&)m1, (const MatrixView_<E2>&)m2, n, tol); }
347  template <class E1, class E2>
348  static bool numericallyEqual(const MatrixView_<E1>& m1, const Matrix_<E2>& m2, int n, double tol=(defTol2<E1,E2>()))
349  { return numericallyEqual((const MatrixView_<E1>&)m1, (const MatrixView_<E2>&)m2, n, tol); }
350 
351  template <class P>
352  static bool numericallyEqual(const Rotation_<P>& R1, const Rotation_<P>& R2, int n, double tol=defTol<P>()) {
353  return R1.isSameRotationToWithinAngle(R2, (Real)(n*tol));
354  }
355 
356  template <class P>
357  static bool numericallyEqual(const Transform_<P>& T1, const Transform_<P>& T2, int n, double tol=defTol<P>()) {
358  return numericallyEqual(T1.R(), T2.R(), n, tol)
359  && numericallyEqual(T1.p(), T2.p(), n, tol);
360  }
361 
362  template <class P>
363  static bool numericallyEqual(const UnitInertia_<P>& G1, const UnitInertia_<P>& G2, int n, double tol=defTol<P>()) {
364  return numericallyEqual(G1.asSymMat33(),G2.asSymMat33(), n, tol);
365  }
366 
367  template <class P>
368  static bool numericallyEqual(const Inertia_<P>& I1, const Inertia_<P>& I2, int n, double tol=defTol<P>()) {
369  return numericallyEqual(I1.asSymMat33(),I2.asSymMat33(), n, tol);
370  }
371 
372  // Random numbers
373  static Real randReal() {
374  static Random::Uniform rand(-1,1);
375  return rand.getValue();
376  }
377  static Complex randComplex() {return Complex(randReal(),randReal());}
379  static float randFloat() {return (float)randReal();}
380  static double randDouble() {return (double)randReal();}
381 
382  template <int M> static Vec<M> randVec()
383  { Vec<M> v; for (int i=0; i<M; ++i) v[i]=randReal(); return v;}
384  template <int N> static Row<N> randRow() {return ~randVec<N>();}
385  template <int M, int N> static Mat<M,N> randMat()
386  { Mat<M,N> m; for (int j=0; j<N; ++j) m(j)=randVec<M>(); return m;}
387  template <int N> static SymMat<N> randSymMat()
388  { SymMat<N> s; s.updAsVec() = randVec<N*(N+1)/2>(); return s; }
389 
390  static Vector randVector(int m)
391  { Vector v(m); for (int i=0; i<m; ++i) v[i]=randReal(); return v;}
392  static Matrix randMatrix(int m, int n)
393  { Matrix M(m,n); for (int j=0; j<n; ++j) M(j)=randVector(m); return M;}
394 
395  static Vec3 randVec3() {return randVec<3>();}
396  static Mat33 randMat33() {return randMat<3,3>();}
397  static SymMat33 randSymMat33() {return randSymMat<3>();}
399  return SpatialVec(randVec3(), randVec3());
400  }
402  return SpatialMat(randMat33(), randMat33(),
403  randMat33(), randMat33());
404  }
406  // Generate random angle and random axis to rotate around.
407  return Rotation((Pi/2)*randReal(), randVec3());
408  }
410  return Transform(randRotation(), randVec3());
411  }
412 private:
413  const double startCpuTime;
414  const double startRealTime;
415  std::string testName;
416 };
417 
420 public:
421  Subtest(const std::string& name)
422  : startCpuTime(SimTK::cpuTime()),
423  startRealTime(SimTK::realTime()),
424  subtestName(name)
425  {
426  std::clog << " " << subtestName << " ...\n" << std::flush;
427  }
429  const double finalRealTime=SimTK::realTime();
430  const double finalCpuTime=SimTK::cpuTime();
431  std::ostringstream fmt;
432  fmt << std::fixed << std::setprecision(1);
433  fmt << " " << subtestName << " done."
434  << " real/CPU ms: " << (finalRealTime-startRealTime)*1000
435  << " / " << (finalCpuTime-startCpuTime)*1000 <<std::endl;
436  std::clog << fmt.str();
437  }
438 private:
439  const double startCpuTime;
440  const double startRealTime;
441  std::string subtestName;
442 };
443 
444 } // namespace SimTK
445 
447 #define SimTK_START_TEST(testName) \
448  SimTK::Test simtk_test_(testName); \
449  try {
450 
452 #define SimTK_END_TEST() \
453  } catch(const std::exception& e) { \
454  std::cerr << "Test failed due to exception: " \
455  << e.what() << std::endl; \
456  return 1; \
457  } catch(...) { \
458  std::cerr << "Test failed due to unrecognized exception.\n"; \
459  return 1; \
460  } \
461  return 0;
462 
465 #define SimTK_SUBTEST(testFunction) \
466  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)();} while(false)
469 #define SimTK_SUBTEST1(testFunction,arg1) \
470  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1);} while(false)
473 #define SimTK_SUBTEST2(testFunction,arg1,arg2) \
474  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2);} while(false)
477 #define SimTK_SUBTEST3(testFunction,arg1,arg2,arg3) \
478  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2,arg3);} while(false)
481 #define SimTK_SUBTEST4(testFunction,arg1,arg2,arg3,arg4) \
482  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2,arg3,arg4);} while(false)
483 
485 #define SimTK_TEST(cond) {SimTK_ASSERT_ALWAYS((cond), "Test condition failed.");}
486 
489 #define SimTK_TEST_FAILED(msg) {SimTK_ASSERT_ALWAYS(!"Test case failed.", msg);}
490 
494 #define SimTK_TEST_FAILED1(fmt,a1) {SimTK_ASSERT1_ALWAYS(!"Test case failed.",fmt,a1);}
495 
499 #define SimTK_TEST_FAILED2(fmt,a1,a2) {SimTK_ASSERT2_ALWAYS(!"Test case failed.",fmt,a1,a2);}
500 
504 #define SimTK_TEST_EQ(v1,v2) \
505  {SimTK_ASSERT_ALWAYS(SimTK::Test::numericallyEqual((v1),(v2),1), \
506  "Test values should have been numerically equivalent at default tolerance.");}
507 
510 #define SimTK_TEST_EQ_SIZE(v1,v2,n) \
511  {SimTK_ASSERT1_ALWAYS(SimTK::Test::numericallyEqual((v1),(v2),(n)), \
512  "Test values should have been numerically equivalent at size=%d times default tolerance.",(n));}
513 
517 #define SimTK_TEST_EQ_TOL(v1,v2,tol) \
518  {SimTK_ASSERT1_ALWAYS(SimTK::Test::numericallyEqual((v1),(v2),1,(tol)), \
519  "Test values should have been numerically equivalent at tolerance=%g.",(tol));}
520 
524 #define SimTK_TEST_NOTEQ(v1,v2) \
525  {SimTK_ASSERT_ALWAYS(!SimTK::Test::numericallyEqual((v1),(v2),1), \
526  "Test values should NOT have been numerically equivalent (at default tolerance).");}
527 
531 #define SimTK_TEST_NOTEQ_SIZE(v1,v2,n) \
532  {SimTK_ASSERT1_ALWAYS(!SimTK::Test::numericallyEqual((v1),(v2),(n)), \
533  "Test values should NOT have been numerically equivalent at size=%d times default tolerance.",(n));}
534 
538 #define SimTK_TEST_NOTEQ_TOL(v1,v2,tol) \
539  {SimTK_ASSERT1_ALWAYS(!SimTK::Test::numericallyEqual((v1),(v2),1,(tol)), \
540  "Test values should NOT have been numerically equivalent at tolerance=%g.",(tol));}
541 
542 #ifndef SimTK_TEST_SUPPRESS_EXPECTED_THROW
543 
545 #define SimTK_TEST_MUST_THROW(stmt) \
546  do {int threw=0; try {stmt;} \
547  catch(const std::exception&){threw=1;} \
548  catch(...){threw=2;} \
549  if (threw==0) SimTK_TEST_FAILED1("Expected statement\n----\n%s\n----\n to throw an exception but it did not.",#stmt); \
550  if (threw==2) SimTK_TEST_FAILED1("Expected statement\n%s\n to throw an std::exception but it threw something else.",#stmt); \
551  }while(false)
552 
555 #define SimTK_TEST_MUST_THROW_SHOW(stmt) \
556  do {int threw=0; try {stmt;} \
557  catch(const std::exception& e) {threw=1; \
558  std::cout << "(OK) Threw: " << e.what() << std::endl;} \
559  catch(...){threw=2;} \
560  if (threw==0) SimTK_TEST_FAILED1("Expected statement\n----\n%s\n----\n to throw an exception but it did not.",#stmt); \
561  if (threw==2) SimTK_TEST_FAILED1("Expected statement\n%s\n to throw an std::exception but it threw something else.",#stmt); \
562  }while(false)
563 
565 #define SimTK_TEST_MUST_THROW_EXC(stmt,exc) \
566  do {int threw=0; try {stmt;} \
567  catch(const exc&){threw=1;} \
568  catch(...){threw=2;} \
569  if (threw==0) SimTK_TEST_FAILED1("Expected statement\n----\n%s\n----\n to throw an exception but it did not.",#stmt); \
570  if (threw==2) SimTK_TEST_FAILED2("Expected statement\n----\n%s\n----\n to throw exception type %s but it threw something else.",#stmt,#exc); \
571  }while(false)
572 
574 #define SimTK_TEST_MAY_THROW(stmt) \
575  do {int threw=0; try {stmt;} \
576  catch(const std::exception&){threw=1;} \
577  catch(...){threw=2;} \
578  if (threw==2) SimTK_TEST_FAILED1("Expected statement\n%s\n to throw an std::exception but it threw something else.",#stmt); \
579  }while(false)
580 
582 #define SimTK_TEST_MAY_THROW_EXC(stmt,exc) \
583  do {int threw=0; try {stmt;} \
584  catch(const exc&){threw=1;} \
585  catch(...){threw=2;} \
586  if (threw==2) SimTK_TEST_FAILED2("Expected statement\n----\n%s\n----\n to throw exception type %s but it threw something else.",#stmt,#exc); \
587  }while(false)
588 
589 // When we're only required to throw in Debug, we have to suppress the
590 // test case altogether in Release because it may cause damage.
591 #ifdef NDEBUG
594  #define SimTK_TEST_MUST_THROW_DEBUG(stmt)
597  #define SimTK_TEST_MUST_THROW_EXC_DEBUG(stmt,exc)
598 #else
601  #define SimTK_TEST_MUST_THROW_DEBUG(stmt) SimTK_TEST_MUST_THROW(stmt)
604  #define SimTK_TEST_MUST_THROW_EXC_DEBUG(stmt,exc) \
605  SimTK_TEST_MUST_THROW_EXC(stmt,exc)
606 #endif
607 
608 #else // expected throws are suppressed
609 #define SimTK_TEST_MUST_THROW(stmt)
610 #define SimTK_TEST_MUST_THROW_SHOW(stmt)
611 #define SimTK_TEST_MUST_THROW_EXC(stmt,exc)
612 #define SimTK_TEST_MAY_THROW(stmt)
613 #define SimTK_TEST_MAY_THROW_EXC(stmt,exc)
614 #define SimTK_TEST_MUST_THROW_DEBUG(stmt)
615 #define SimTK_TEST_MUST_THROW_EXC_DEBUG(stmt,exc)
616 #endif
617 
618 
619 // End of Regression testing group.
621 
622 #endif // SimTK_SimTKCOMMON_TESTING_H_
This is the header which should be included in user programs that would like to make use of all the S...
This file ensures that we have access to the Posix time functions clock_getttime() and nanosleep(),...
Includes internal headers providing declarations for the basic SimTK Core classes.
The physical meaning of an inertia is the distribution of a rigid body's mass about a particular poin...
Definition: MassProperties.h:193
const SymMat< 3, P > & asSymMat33() const
Obtain a reference to the underlying symmetric matrix type.
Definition: MassProperties.h:397
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition: Mat.h:97
int nrow() const
Return the number of rows m in the logical shape of this matrix.
Definition: MatrixBase.h:136
int ncol() const
Return the number of columns n in the logical shape of this matrix.
Definition: MatrixBase.h:138
(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignm...
Definition: MatrixView_.h:43
This is the matrix class intended to appear in user code for large, variable size matrices.
Definition: Matrix_.h:51
Definition: NTraits.h:436
This is a subclass of Random that generates numbers uniformly distributed within a specified range.
Definition: Random.h:96
Real getValue() const
Get the next value in the pseudo-random sequence.
The Rotation class is a Mat33 that guarantees that the matrix can be interpreted as a legitimate 3x3 ...
Definition: Rotation.h:111
bool isSameRotationToWithinAngle(const Rotation_ &R, RealP okPointingAngleErrorRads) const
Return true if "this" Rotation is nearly identical to "R" within a specified pointing angle error.
int size() const
Definition: RowVectorBase.h:237
(Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assi...
Definition: RowVectorView_.h:42
Represents a variable size row vector; much less common than the column vector type Vector_.
Definition: RowVector_.h:52
This is a fixed-length row vector designed for no-overhead inline computation.
Definition: Row.h:132
This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation...
Definition: SymMat.h:87
const TAsVec & getAsVec() const
Definition: SymMat.h:831
TAsVec & updAsVec()
Definition: SymMat.h:832
Internal utility class for generating test messages for subtests.
Definition: Testing.h:419
This is the main class to support testing.
Definition: Testing.h:163
This class represents the rotate-and-shift transform which gives the location and orientation of a ne...
Definition: Transform.h:108
const Vec< 3, P > & p() const
Return a read-only reference to our translation vector p_BF.
Definition: Transform.h:239
const Rotation_< P > & R() const
Return a read-only reference to the contained rotation R_BF.
Definition: Transform.h:215
A UnitInertia matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying i...
Definition: MassProperties.h:669
This is a fixed-length column vector designed for no-overhead inline computation.
Definition: Vec.h:184
int size() const
Definition: VectorBase.h:396
(Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignm...
Definition: VectorView_.h:42
This is the vector class intended to appear in user code for large, variable size column vectors.
Definition: Vector_.h:50
SimTK::conjugate<R> should be instantiated only for float, double.
Definition: conjugate.h:178
negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically...
Definition: negator.h:75
double cpuTime()
Return the cumulative CPU time in seconds (both kernel and user time) that has been used so far by an...
Definition: Timing.h:228
double realTime()
Return current time on the high-resolution interval timer in seconds.
Definition: Timing.h:290
Test(const std::string &name)
Definition: Testing.h:166
static Real randReal()
Definition: Testing.h:373
static bool numericallyEqual(const VectorView_< E1 > &v1, const Vector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:314
static SpatialVec randSpatialVec()
Definition: Testing.h:398
static bool numericallyEqual(const Inertia_< P > &I1, const Inertia_< P > &I2, int n, double tol=defTol< P >())
Definition: Testing.h:368
static Row< N > randRow()
Definition: Testing.h:384
static bool numericallyEqual(const conjugate< P > &v1, const negator< std::complex< P > > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:278
static bool numericallyEqual(const RowVector_< E1 > &v1, const RowVectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:328
static bool numericallyEqual(const MatrixView_< E1 > &m1, const Matrix_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:348
static bool numericallyEqual(const negator< P > &v1, const P &v2, int n, double tol=defTol< P >())
Definition: Testing.h:262
static bool numericallyEqual(const Matrix_< E1 > &m1, const Matrix_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:342
static bool numericallyEqual(const UnitInertia_< P > &G1, const UnitInertia_< P > &G2, int n, double tol=defTol< P >())
Definition: Testing.h:363
static double defTol2()
Definition: Testing.h:189
static float randFloat()
Definition: Testing.h:379
static bool numericallyEqual(double v1, double v2, int n, double tol=defTol< double >())
Definition: Testing.h:200
static double defTol()
Definition: Testing.h:185
static bool numericallyEqual(double f1, int i2, int n, double tol=defTol< double >())
Definition: Testing.h:226
static bool numericallyEqual(const RowVectorView_< E1 > &v1, const RowVector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:331
static Vec3 randVec3()
Definition: Testing.h:395
static bool numericallyEqual(int i1, double f2, int n, double tol=defTol< double >())
Definition: Testing.h:224
static bool numericallyEqual(unsigned u1, unsigned u2, int n, double tol=0)
Definition: Testing.h:207
static double randDouble()
Definition: Testing.h:380
static bool numericallyEqual(const negator< conjugate< P > > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:270
static Complex randComplex()
Definition: Testing.h:377
static bool numericallyEqual(const std::complex< P > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:244
static bool numericallyEqual(const Rotation_< P > &R1, const Rotation_< P > &R2, int n, double tol=defTol< P >())
Definition: Testing.h:352
static Vector randVector(int m)
Definition: Testing.h:390
static bool numericallyEqual(const negator< P > &v1, const negator< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:254
static bool numericallyEqual(const RowVector_< E1 > &v1, const RowVector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:325
static bool numericallyEqual(const std::complex< P > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:234
static bool numericallyEqual(float f1, int i2, int n, double tol=defTol< float >())
Definition: Testing.h:218
static Mat33 randMat33()
Definition: Testing.h:396
static Vec< M > randVec()
Definition: Testing.h:382
Subtest(const std::string &name)
Definition: Testing.h:421
static bool numericallyEqual(int i1, float f2, int n, double tol=defTol< float >())
Definition: Testing.h:216
static bool numericallyEqual(double f1, unsigned i2, int n, double tol=defTol< double >())
Definition: Testing.h:230
static bool numericallyEqual(double v1, float v2, int n, double tol=defTol< float >())
Definition: Testing.h:212
static bool numericallyEqual(const SymMat< N, E1, S1 > &v1, const SymMat< N, E2, S2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:297
~Test()
Definition: Testing.h:173
static bool numericallyEqual(const P &v1, const negator< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:258
static Transform randTransform()
Definition: Testing.h:409
static SymMat33 randSymMat33()
Definition: Testing.h:397
static bool numericallyEqual(const Row< N, E1, S1 > &v1, const Row< N, E2, S2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:287
static SymMat< N > randSymMat()
Definition: Testing.h:387
static bool numericallyEqual(const Mat< M, N, E1, CS1, RS1 > &v1, const Mat< M, N, E2, CS2, RS2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:292
static bool numericallyEqual(const conjugate< P > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:239
static bool numericallyEqual(const Vector_< E1 > &v1, const VectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:311
~Subtest()
Definition: Testing.h:428
static bool numericallyEqual(const MatrixView_< E1 > &v1, const MatrixView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:335
static bool numericallyEqual(float f1, unsigned i2, int n, double tol=defTol< float >())
Definition: Testing.h:222
static Rotation randRotation()
Definition: Testing.h:405
static bool numericallyEqual(const Vector_< E1 > &v1, const Vector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:308
static bool numericallyEqual(const Matrix_< E1 > &m1, const MatrixView_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:345
static Mat< M, N > randMat()
Definition: Testing.h:385
static bool numericallyEqual(const Vec< M, E1, S1 > &v1, const Vec< M, E2, S2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:282
static bool numericallyEqual(const std::complex< P > &v1, const negator< conjugate< P > > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:274
static bool numericallyEqual(const conjugate< P > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:249
static bool numericallyEqual(const RowVectorView_< E1 > &v1, const RowVectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:318
static bool numericallyEqual(const Transform_< P > &T1, const Transform_< P > &T2, int n, double tol=defTol< P >())
Definition: Testing.h:357
static bool numericallyEqual(const VectorView_< E1 > &v1, const VectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:301
static bool numericallyEqual(const negator< std::complex< P > > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:266
static bool numericallyEqual(int i1, int i2, int n, double tol=0)
Definition: Testing.h:206
static Conjugate randConjugate()
Definition: Testing.h:378
static bool numericallyEqual(unsigned i1, double f2, int n, double tol=defTol< double >())
Definition: Testing.h:228
static SpatialMat randSpatialMat()
Definition: Testing.h:401
static Matrix randMatrix(int m, int n)
Definition: Testing.h:392
static bool numericallyEqual(float v1, float v2, int n, double tol=defTol< float >())
Definition: Testing.h:196
static bool numericallyEqual(unsigned i1, float f2, int n, double tol=defTol< float >())
Definition: Testing.h:220
static bool numericallyEqual(float v1, double v2, int n, double tol=defTol< float >())
Definition: Testing.h:210
Vec< 2, Vec3 > SpatialVec
Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects,...
Definition: MassProperties.h:50
Mat< 2, 2, Mat33 > SpatialMat
Spatial matrices are used to hold 6x6 matrices that are best viewed as 2x2 matrices of 3x3 matrices; ...
Definition: MassProperties.h:72
const Real Pi
Real(pi)
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
Rotation_< Real > Rotation
Definition: Rotation.h:47
std::complex< Real > Complex
This is the default complex type for SimTK, with precision for the real and imaginary parts set to th...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:610
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
RowVectorBase< typename CNT< ELEM >::TAbs > abs(const RowVectorBase< ELEM > &v)
Definition: VectorMath.h:120
conjugate< Real > Conjugate
Definition: Scalar.h:57
SimTK_Real Real
This is the default compiled-in floating point type for SimTK, either float or double.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:607
Transform_< Real > Transform
Definition: Transform.h:44