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"
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
RowVectorBase< typename CNT< ELEM >::TAbs > abs(const RowVectorBase< ELEM > &v)
Definition: VectorMath.h:120
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
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
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