void QuatGenMetricTest::testGenTimingMakeInvert2()
{
gmtl::Quat<float> q2;
const long iters(25000);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
q2 = gmtl::makeInvert( q2 );
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/makeInvert(quatf)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// force intelligent compilers to do all the iterations (ie. to not optimize them out),
// by using the variables computed...
CPPUNIT_ASSERT( q2[0] != 10000.0f );
}
void EulerAngleClassMetricTest::testEulerAngleTimingOpEqual()
{
const long iters( 400000 );
gmtl::EulerAngleXYZf q4, q2( 0.0f, 2.0f, 1.0f );
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of operator=() function
q4 = q2;
q2[0] += q4[2];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("EulerAngleTest/operator=()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( q4[0] != 3498.0f );
}
void PointMetricTest::testTimingOpDivScalarEq()
{
gmtl::Point<float,3> test_point1(12.0, 8.0, 4.0);
// -- test op-= performance
const float iters(400000);
CPPUNIT_METRIC_START_TIMING();
for( float iter=0;iter<iters; ++iter)
{
test_point1 /= 0.95f;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("PointTest/OpDivScalarEqOverhead", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
}
void QuatClassMetricTest::testQuatTimingOpEqual()
{
const long iters( 400000 );
gmtl::Quat<float> q4, q2( 0, 2, 1, 3 );
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of operator=() function
q4 = q2;
q2[0] += q4[2];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/operator=()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( q4[0] != 3498.0f );
}
void EulerAngleClassMetricTest::testEulerAngleTimingGetData()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::EulerAngleXYZf q( 1, 2, 3 );
for (long iter = 0; iter < iters; ++iter)
{
// performance of getData...
const float* d = q.getData();
use_value += d[1];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("EulerAngleTest/getData()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value > 0.0f );
}
void QuatClassMetricTest::testQuatTimingGetData()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::Quat<float> q;
for (long iter = 0; iter < iters; ++iter)
{
// performance of getData...
const float* d = q.getData();
use_value += d[3];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/getData()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value > 0.0f );
}
void QuatClassMetricTest::testQuatTimingSet()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::Quat<float> q;
for (long iter = 0; iter < iters; ++iter)
{
// performance of set...
q.set( 1, 2, 3, 4 );
use_value += q[gmtl::Xelt];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/set()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value >= 0.0f );
}
void EulerAngleClassMetricTest::testEulerAngleTimingSet()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::EulerAngleXYZf q;
for (long iter = 0; iter < iters; ++iter)
{
// performance of set...
q.set( 1, 2, 3 );
use_value += q[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("EulerAngleTest/set()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value >= 0.0f );
}
void QuatClassMetricTest::testQuatTimingElementConstructor()
{
const long iters( 400000 );
float use_value(1);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of element constructor
gmtl::Quat<float> q2( 10, 11, 12, 13 );
use_value += q2.mData[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/ElementConstructor", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 0 );
}
void AxisAngleClassMetricTest::testAxisAngleTimingDefaultConstructor()
{
const long iters( 400000 );
float use_value(1);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of def constructor
gmtl::AxisAnglef q;
use_value += q.mData[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("AxisAngleTest/DefaultConstructor", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 0 );
}
void EulerAngleClassMetricTest::testEulerAngleTimingElementConstructor()
{
const long iters( 400000 );
float use_value(1);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of element constructor
gmtl::EulerAngleXYZf q2( 10.0f, 11.0f, 12.0f );
use_value += q2[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("EulerAngleTest/ElementConstructor", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 0 );
}
void CoordGenMetricTest::testGenTimingSetCoord()
{
gmtl::Matrix44f mat;
gmtl::Coord<gmtl::Vec<float,3>, gmtl::EulerAngle<float, gmtl::XYZ> > q1;
const long iters(25000);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::set( q1, mat );
mat[3][3] += q1.getPos()[2];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "CoordGenTest/set(coord,mat)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( q1.pos()[1] != 10000.0f );
}
void CoordClassMetricTest::testCoordTimingDefaultConstructor()
{
const long iters( 400000 );
float use_value(1);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of def constructor
gmtl::Coord<gmtl::Vec<float,3>, gmtl::EulerAngle<float, gmtl::XYZ> > q;
use_value += q.mPos[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("CoordTest/DefaultConstructor", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 0 );
}
void CoordGenMetricTest::testGenTimingMakeMatrix()
{
gmtl::Matrix44f mat;
gmtl::Coord<gmtl::Vec<float,3>, gmtl::EulerAngle<float, gmtl::XYZ> > q1;
const long iters(25000);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
mat = gmtl::make<gmtl::Matrix44f>( q1 );
q1.pos()[2] += mat[3][3];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "CoordGenTest/make<Matrix44f>(q1,XYZ)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( q1.pos()[1] != 10000.0f );
}
void QuatClassMetricTest::testQuatTimingGet()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::Quat<float> q;
float x = 102, y = 103, z = 101, w = 100;
for (long iter = 0; iter < iters; ++iter)
{
// performance of get...
q.get( x, y, z, w );
use_value = use_value + x + y + z + w;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/get()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value > 0.0f );
}
void EulerAngleClassMetricTest::testEulerAngleTimingCopyConstructor()
{
const long iters( 400000 );
float use_value(1);
gmtl::EulerAngleXYZf q( 67.0f, 68.0f, 69.0f );
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of copy constructor
gmtl::EulerAngleXYZf q3( q );
use_value += q3[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("EulerAngleTest/CopyConstructor", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 0 );
}
void QuatClassMetricTest::testQuatTimingCopyConstructor()
{
const long iters( 400000 );
float use_value(1);
gmtl::Quat<float> q( 67, 68, 69, 60 );
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
// performance of copy constructor
gmtl::Quat<float> q3( q );
use_value += q3.mData[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/CopyConstructor", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 0 );
}
void PointMetricTest::testTimingOpMultScalar()
{
gmtl::Point<float,3> test_point1(1.0, 2.0, 3.0);
gmtl::Point<float,3> test_point3(1.0, 2.0, 3.0);
// -- test op- performance
const float iters(400000);
CPPUNIT_METRIC_START_TIMING();
test_point3.set(5.0, 7.0, 9.0);
for( float iter=0;iter<iters; ++iter)
{
test_point1 = test_point3 * 1.05f;
test_point3 = test_point1;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("PointTest/OpMultScalarOverhead", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
}
void QuatCompareMetricTest::testQuatTimingEquiv()
{
gmtl::Quatf quat1(1.0, 2.0, 34.0, 4.0),
quat2(-1.0, -2.0, -34.0, -4.0);
unsigned true_count(0);
const long iters(200000);
CPPUNIT_METRIC_START_TIMING();
for( long iter=0;iter<iters; ++iter)
{
if (gmtl::isEquiv( quat1, quat2, 0.0001f ) )
++true_count;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatCompareTest/isEquiv(quat,quat,tol)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// Make sure the compiler doesn't optimize out true_count
CPPUNIT_ASSERT( true_count > 0 );
}
void CoordClassMetricTest::testCoordTimingGet()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::Coord<gmtl::Vec<float,3>, gmtl::EulerAngle<float, gmtl::XYZ> > q;
for (long iter = 0; iter < iters; ++iter)
{
// performance of get...
use_value += use_value + q.pos()[0];
use_value += use_value + q.rot()[0];
q.rot()[0] -= use_value;
q.pos()[0] -= use_value;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("CoordTest/get()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value != 8324908723.0f );
}
void AABoxContainMetricTest::testTimingIsInVolumePt()
{
gmtl::AABoxf box(gmtl::Point3f(-1,-1,-1), gmtl::Point3f(1,1,1));
gmtl::Point3f origin;
const long iters(400000);
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
for(long iter=0;iter<iters; ++iter)
{
gmtl::isInVolume(box, origin);
use_value = use_value + box.mMin[0] + 2.0f;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("AABoxContainTest/IsInVolumePt", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT(use_value > 0.0f);
}
void EulerAngleClassMetricTest::testEulerAngleTimingOpBracket()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::EulerAngleXYZf q;
float x = 102.0f, y = 103.0f, z = 101.0f;
for (long iter = 0; iter < iters; ++iter)
{
// performance of brackets
q[0] = x;
q[1] = y;
q[2] = z;
use_value = use_value + x + y + z;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("EulerAngleTest/operator[]()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value > 0.0f );
}
void PointMetricTest::testTimingOpMinusEq()
{
gmtl::Point<float,3> test_point1(1.0, 2.0, 3.0);
gmtl::Point<float,3> test_point2(2.0, 2.0, 2.0);
// -- test op-= performance
const float iters(400000);
CPPUNIT_METRIC_START_TIMING();
gmtl::Point<float,3> test_point3(5.0, 7.0, 9.0);
for( float iter=0;iter<iters; ++iter)
{
test_point3.set(iter, iter+1, iter+2);
test_point1 -= test_point3;
}
test_point2 = test_point1;
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("PointTest/OpMinusEqOverhead", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
}
void QuatClassMetricTest::testQuatTimingOpBracket()
{
const long iters( 400000 );
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
gmtl::Quat<float> q;
float x = 102, y = 103, z = 101, w = 100;
for (long iter = 0; iter < iters; ++iter)
{
// performance of brackets
q[gmtl::Xelt] = x;
q[gmtl::Yelt] = y;
q[gmtl::Zelt] = z;
q[gmtl::Welt] = w;
use_value = use_value + x + y + z + w;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("QuatTest/operator[]()", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value > 0.0f );
}
void PointMetricTest::testTimingConstructors()
{
// Test constructor
const long iters(400000);
float use_value(0.0f); // A temp just here to use the objs so the copiler (hopefully) does not opt them out
CPPUNIT_METRIC_START_TIMING();
for( long iter=0;iter<iters; ++iter)
{
gmtl::Point<float, 4> test_point4(1.0f, 2.0f, 3.0f, 4.0f);
gmtl::Point<float, 3> test_point3(1.0f, 2.0f, 3.0f);
gmtl::Point<float, 2> test_point2(1.0f, 2.0f);
gmtl::Point<float, 1> test_point1;
test_point1.set(1.0f);
use_value = use_value + test_point4[3] + test_point3[2] + test_point2[1] + test_point1[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("PointTest/ConstructorsOverhead", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
}
void testTimingZeroClamp()
{
// test performance
const long iters(400000);
T use_val(0);
T val = T(0);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
val += T(0.5);
use_val += gmtl::Math::zeroClamp( val, T(0.4) );
use_val += gmtl::Math::zeroClamp( val, T(0.2) );
}
CPPUNIT_METRIC_STOP_TIMING();
std::string typeName = std::string("MathTest/ZeroClamp[") + std::string(typeid(T).name()) + std::string("]");
CPPUNIT_ASSERT_METRIC_TIMING_LE(typeName, iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// make sure the compiler doesn't optimize out use_val
CPPUNIT_ASSERT( use_val > 0 );
}
void PointMetricTest::testTimingCreation()
{
// Test overhead of creation
const long iters(400000);
float use_value(0);
CPPUNIT_METRIC_START_TIMING();
for( long iter=0;iter<iters; ++iter)
{
gmtl::Point<float, 2> test_point2;
test_point2[0] = 1.0f;
gmtl::Point<float, 3> test_point3;
test_point3[0] = 2.0f;
gmtl::Point<float, 4> test_point4;
test_point4[0] = 3.0f;
use_value += test_point2[0] + test_point3[0] + test_point4[0];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE("PointTest/pointCreationOverhead", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
CPPUNIT_ASSERT( use_value > 0.0f );
}
void MathMetricTest::testFastInvSqrt()
{
/*
std::cout << "--- Inverse sqrts ---" << std::endl;
for(float x=0.001;x<10.0f;x+=0.05f)
{
std::cout << x << ", "
<< 1.0/gmtl::Math::sqrt(x) << ", "
<< gmtl::Math::fastInvSqrt(x) << ", "
<< gmtl::Math::fastInvSqrt2(x) << ", "
<< gmtl::Math::fastInvSqrt3(x) << std::endl;
}
std::cout << "---- more ----" << std::endl;
for(float x=1;x<10000.0f;x+=100.0f)
{
std::cout << x << ", "
<< 1.0/gmtl::Math::sqrt(x) << ", "
<< gmtl::Math::fastInvSqrt(x) << ", "
<< gmtl::Math::fastInvSqrt2(x) << ", "
<< gmtl::Math::fastInvSqrt3(x) << std::endl;
}
*/
const long iters(100000);
{
// stdInvSqrt
float use_val(0);
float val(0.001f);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
val += 0.05f;
use_val += (1.0f/gmtl::Math::sqrt(val));
}
CPPUNIT_METRIC_STOP_TIMING();
std::string typeName = std::string("MathTest/stdInvSqrt");
CPPUNIT_ASSERT_METRIC_TIMING_LE(typeName, iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// make sure the compiler doesn't optimize out use_val
CPPUNIT_ASSERT( use_val > 0 );
}
{
// fastInvSqrt
float use_val(0);
float val(0.001f);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
val += 0.05f;
use_val += gmtl::Math::fastInvSqrt(val);
}
CPPUNIT_METRIC_STOP_TIMING();
std::string typeName = std::string("MathTest/fastInvSqrt");
CPPUNIT_ASSERT_METRIC_TIMING_LE(typeName, iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// make sure the compiler doesn't optimize out use_val
CPPUNIT_ASSERT( use_val > 0 );
}
{
// fastInvSqrt2
float use_val(0);
float val(0.001f);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
val += 0.05f;
use_val += gmtl::Math::fastInvSqrt2(val);
}
CPPUNIT_METRIC_STOP_TIMING();
std::string typeName = std::string("MathTest/fastInvSqrt2");
CPPUNIT_ASSERT_METRIC_TIMING_LE(typeName, iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// make sure the compiler doesn't optimize out use_val
CPPUNIT_ASSERT( use_val > 0 );
}
{
// fastInvSqrt3
float use_val(0);
float val(0.001f);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
val += 0.05f;
use_val += gmtl::Math::fastInvSqrt3(val);
}
CPPUNIT_METRIC_STOP_TIMING();
std::string typeName = std::string("MathTest/fastInvSqrt3");
CPPUNIT_ASSERT_METRIC_TIMING_LE(typeName, iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// make sure the compiler doesn't optimize out use_val
CPPUNIT_ASSERT( use_val > 0 );
}
}
void QuatGenMetricTest::testGenTimingSetRot()
{
double bokd = 1;
float bokf = 1;
gmtl::Quat<double> q1;
const long iters(25000);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::set( q1, gmtl::makeNormal( gmtl::AxisAngled( bokd, bokd, bokd, bokd ) ) );
bokd += q1[2];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatd,axisangled)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
gmtl::Quat<float> q2; bokf = 1.0f;
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::set( q2, gmtl::makeNormal( gmtl::AxisAnglef( bokf, bokf, bokf, bokf ) ) );
bokf -= q2[3];
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatf,axisanglef)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
gmtl::Quat<double> q3; bokd = 1.0f;
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::set( q3, gmtl::makeNormal( gmtl::AxisAngled( bokd, gmtl::Vec<double, 3>( bokd, bokd, bokd ) ) ) );
bokd *= q3[1] + 1.2;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatd,axisangled(r,vec))", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
gmtl::Quat<float> q4; bokf = 1.0f;
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::set( q4, gmtl::makeNormal( gmtl::AxisAnglef( bokf, gmtl::Vec<float, 3>( bokf, bokf, bokf ) ) ) );
bokf += q4[1] + 1.2f;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatf,axisanglef(r,vec))", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
gmtl::Quat<double> q5;
gmtl::Vec<double, 3> v4(1,2,3), v5(1,2,3);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::setRot( q5, gmtl::makeNormal( v4 ), gmtl::makeNormal( v5 ) );
v4[2] += q5[1] + 1.2;
v5[0] -= q5[2] + 1.2;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatd,vec3d,vec3d)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
gmtl::Quat<float> q6;
gmtl::Vec<float, 3> v6(1,2,3), v7(1,2,3);
CPPUNIT_METRIC_START_TIMING();
for (long iter = 0; iter < iters; ++iter)
{
gmtl::setRot( q6, gmtl::makeNormal( v6 ), gmtl::makeNormal( v7 ) );
v6[2] += q6[1] + 1.2f;
v7[0] -= q6[2] + 1.2f;
}
CPPUNIT_METRIC_STOP_TIMING();
CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatf,vec3f,vec3f)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10%
// force intelligent compilers to do all the iterations (ie. to not optimize them out),
// by using the variables computed...
CPPUNIT_ASSERT( bokf != 0.998f );
CPPUNIT_ASSERT( bokd != 0.0998 );
CPPUNIT_ASSERT( q1[0] != 10000.0f );
CPPUNIT_ASSERT( q2[1] != 10000.0f );
CPPUNIT_ASSERT( q3[2] != 10000.0f );
CPPUNIT_ASSERT( q4[3] != 10000.0f );
CPPUNIT_ASSERT( q5[0] != 10000.0f );
CPPUNIT_ASSERT( q6[1] != 10000.0f );
}
