Simbody 3.7
Loading...
Searching...
No Matches
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"
31
32#include <cmath>
33#include <algorithm>
34#include <iostream>
35
41namespace SimTK {
42
163class Test {
164public:
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 }
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 }
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 }
412private:
413 const double startCpuTime;
414 const double startRealTime;
415 std::string testName;
416};
417
420public:
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 }
438private:
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 Rotation_< P > & R() const
Return a read-only reference to the contained rotation R_BF.
Definition Transform.h:215
const Vec< 3, P > & p() const
Return a read-only reference to our translation vector p_BF.
Definition Transform.h:239
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 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 Mat< M, N > randMat()
Definition Testing.h:385
static Complex randComplex()
Definition Testing.h:377
static Row< N > randRow()
Definition Testing.h:384
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 SymMat< N > randSymMat()
Definition Testing.h:387
static bool numericallyEqual(float f1, int i2, int n, double tol=defTol< float >())
Definition Testing.h:218
static Mat33 randMat33()
Definition Testing.h:396
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 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
static Vec< M > randVec()
Definition Testing.h:382
~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 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:49
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
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:606
Transform_< Real > Transform
Definition Transform.h:46