Simbody  3.7
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 
159 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)
467 #define SimTK_SUBTEST1(testFunction,arg1) \
470  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1);} while(false)
471 #define SimTK_SUBTEST2(testFunction,arg1,arg2) \
474  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2);} while(false)
475 #define SimTK_SUBTEST3(testFunction,arg1,arg2,arg3) \
478  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2,arg3);} while(false)
479 #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
592  #define SimTK_TEST_MUST_THROW_DEBUG(stmt)
595  #define SimTK_TEST_MUST_THROW_EXC_DEBUG(stmt,exc)
598 #else
599  #define SimTK_TEST_MUST_THROW_DEBUG(stmt) SimTK_TEST_MUST_THROW(stmt)
602  #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_
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
Vec< 2, Vec3 > SpatialVec
Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects...
Definition: MassProperties.h:50
static double defTol2()
Definition: Testing.h:189
static Mat< M, N > randMat()
Definition: Testing.h:385
This is a subclass of Random that generates numbers uniformly distributed within a specified range...
Definition: Random.h:96
Subtest(const std::string &name)
Definition: Testing.h:421
static bool numericallyEqual(const negator< conjugate< P > > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:270
static bool numericallyEqual(const UnitInertia_< P > &G1, const UnitInertia_< P > &G2, int n, double tol=defTol< P >())
Definition: Testing.h:363
This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:621
This is the vector class intended to appear in user code for large, variable size column vectors...
Definition: BigMatrix.h:171
static bool numericallyEqual(const conjugate< P > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:239
static bool numericallyEqual(int i1, double f2, int n, double tol=defTol< double >())
Definition: Testing.h:224
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
static bool numericallyEqual(double f1, int i2, int n, double tol=defTol< double >())
Definition: Testing.h:226
static Row< N > randRow()
Definition: Testing.h:384
static bool numericallyEqual(const RowVector_< E1 > &v1, const RowVectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:328
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
SimTK::conjugate<R> should be instantiated only for float, double.
Definition: String.h:45
Real getValue() const
Get the next value in the pseudo-random sequence.
static Vec3 randVec3()
Definition: Testing.h:395
static bool numericallyEqual(double v1, double v2, int n, double tol=defTol< double >())
Definition: Testing.h:200
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:609
The Rotation class is a Mat33 that guarantees that the matrix can be interpreted as a legitimate 3x3 ...
Definition: Quaternion.h:40
bool isSameRotationToWithinAngle(const Rotation_ &R, RealP okPointingAngleErrorRads) const
Return true if "this" Rotation is nearly identical to "R" within a specified pointing angle error...
static bool numericallyEqual(const negator< P > &v1, const negator< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:254
TAsVec & updAsVec()
Definition: SymMat.h:832
static bool numericallyEqual(const std::complex< P > &v1, const negator< conjugate< P > > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:274
conjugate< Real > Conjugate
Definition: Scalar.h:57
const Rotation_< P > & R() const
Return a read-only reference to the contained rotation R_BF.
Definition: Transform.h:215
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(float v1, double v2, int n, double tol=defTol< float >())
Definition: Testing.h:210
static bool numericallyEqual(const P &v1, const negator< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:258
negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically...
Definition: String.h:44
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 Matrix_< E1 > &m1, const MatrixView_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:345
static Vec< M > randVec()
Definition: Testing.h:382
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:606
static bool numericallyEqual(unsigned u1, unsigned u2, int n, double tol=0)
Definition: Testing.h:207
static bool numericallyEqual(unsigned i1, float f2, int n, double tol=defTol< float >())
Definition: Testing.h:220
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
const TAsVec & getAsVec() const
Definition: SymMat.h:831
static Complex randComplex()
Definition: Testing.h:377
static double randDouble()
Definition: Testing.h:380
static Vector randVector(int m)
Definition: Testing.h:390
(Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assi...
Definition: BigMatrix.h:173
static bool numericallyEqual(const RowVectorView_< E1 > &v1, const RowVector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:331
Rotation_< Real > Rotation
Definition: Rotation.h:47
static SymMat< N > randSymMat()
Definition: Testing.h:387
static bool numericallyEqual(const Matrix_< E1 > &m1, const Matrix_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:342
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 bool numericallyEqual(unsigned i1, double f2, int n, double tol=defTol< double >())
Definition: Testing.h:228
This is a fixed-length column vector designed for no-overhead inline computation. ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:618
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 negator< P > &v1, const P &v2, int n, double tol=defTol< P >())
Definition: Testing.h:262
static bool numericallyEqual(const RowVector_< E1 > &v1, const RowVector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:325
(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:167
static bool numericallyEqual(float f1, int i2, int n, double tol=defTol< float >())
Definition: Testing.h:218
static bool numericallyEqual(const RowVectorView_< E1 > &v1, const RowVectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:318
This class represents the rotate-and-shift transform which gives the location and orientation of a ne...
Definition: Transform.h:43
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
int ncol() const
Return the number of columns n in the logical shape of this matrix.
Definition: MatrixBase.h:138
static Real randReal()
Definition: Testing.h:373
static bool numericallyEqual(float v1, float v2, int n, double tol=defTol< float >())
Definition: Testing.h:196
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 MatrixView_< E1 > &m1, const Matrix_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:348
static bool numericallyEqual(const negator< std::complex< P > > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:266
static SymMat33 randSymMat33()
Definition: Testing.h:397
This is the matrix class intended to appear in user code for large, variable size matrices...
Definition: BigMatrix.h:168
const Real Pi
Real(pi)
RowVectorBase< typename CNT< ELEM >::TAbs > abs(const RowVectorBase< ELEM > &v)
Definition: VectorMath.h:120
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
The physical meaning of an inertia is the distribution of a rigid body&#39;s mass about a particular poin...
Definition: MassProperties.h:82
const SymMat< 3, P > & asSymMat33() const
Obtain a reference to the underlying symmetric matrix type.
Definition: MassProperties.h:397
This is a fixed-length row vector designed for no-overhead inline computation.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:619
A UnitInertia matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying i...
Definition: MassProperties.h:81
static Conjugate randConjugate()
Definition: Testing.h:378
static bool numericallyEqual(const Vector_< E1 > &v1, const VectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:311
Internal utility class for generating test messages for subtests.
Definition: Testing.h:419
static bool numericallyEqual(const Rotation_< P > &R1, const Rotation_< P > &R2, int n, double tol=defTol< P >())
Definition: Testing.h:352
int size() const
Definition: RowVectorBase.h:237
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 Transform randTransform()
Definition: Testing.h:409
Represents a variable size row vector; much less common than the column vector type Vector_...
Definition: BigMatrix.h:174
int size() const
Definition: VectorBase.h:396
static bool numericallyEqual(int i1, int i2, int n, double tol=0)
Definition: Testing.h:206
~Test()
Definition: Testing.h:173
This file ensures that we have access to the Posix time functions clock_getttime() and nanosleep()...
static bool numericallyEqual(const Inertia_< P > &I1, const Inertia_< P > &I2, int n, double tol=defTol< P >())
Definition: Testing.h:368
static bool numericallyEqual(int i1, float f2, int n, double tol=defTol< float >())
Definition: Testing.h:216
static bool numericallyEqual(const VectorView_< E1 > &v1, const Vector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:314
static bool numericallyEqual(const std::complex< P > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:234
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:620
static Mat33 randMat33()
Definition: Testing.h:396
static SpatialVec randSpatialVec()
Definition: Testing.h:398
This is the header which should be included in user programs that would like to make use of all the S...
static Matrix randMatrix(int m, int n)
Definition: Testing.h:392
const Vec< 3, P > & p() const
Return a read-only reference to our translation vector p_BF.
Definition: Transform.h:239
Includes internal headers providing declarations for the basic SimTK Core classes.
static bool numericallyEqual(const Vector_< E1 > &v1, const Vector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:308
static double defTol()
Definition: Testing.h:185
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 MatrixView_< E1 > &v1, const MatrixView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:335
(Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:170
static bool numericallyEqual(const std::complex< P > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:244
static float randFloat()
Definition: Testing.h:379
static Rotation randRotation()
Definition: Testing.h:405
~Subtest()
Definition: Testing.h:428
static bool numericallyEqual(double f1, unsigned i2, int n, double tol=defTol< double >())
Definition: Testing.h:230
Definition: negator.h:64
static SpatialMat randSpatialMat()
Definition: Testing.h:401
int nrow() const
Return the number of rows m in the logical shape of this matrix.
Definition: MatrixBase.h:136
Transform_< Real > Transform
Definition: Transform.h:44
static bool numericallyEqual(float f1, unsigned i2, int n, double tol=defTol< float >())
Definition: Testing.h:222