source: src/unittests/vectorunittest.cpp@ afd01c

/*
 * unittest.cpp
 *
 *  Created on: Aug 17, 2009
 *      Author: heber
 */


using namespace std;

#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>

#include "defs.hpp"
#include "log.hpp"
#include "memoryusageobserver.hpp"
#include "vector.hpp"
#include "vector_ops.hpp"
#include "vectorunittest.hpp"
#include "Plane.hpp"
#include "Exceptions/LinearDependenceException.hpp"

#ifdef HAVE_TESTRUNNER
#include "UnitTestMain.hpp"
#endif /*HAVE_TESTRUNNER*/

#include <iostream>

using namespace std;

/********************************************** Test classes **************************************/

// Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION( VectorTest );


void VectorTest::setUp()
{
  zero  = Vector(0.,0.,0.);
  unit = Vector(1.,0.,0.);
  otherunit = Vector(0.,1.,0.);
  notunit = Vector(0.,1.,1.);
  two = Vector(2.,1.,0.);
  three = Vector(1,2,3);
};


void VectorTest::tearDown()
{
  MemoryUsageObserver::purgeInstance();
  logger::purgeInstance();
  errorLogger::purgeInstance();
};

/** UnitTest for Constructors and Vector::IsZero() and Vector::IsOne().
 */
void VectorTest::UnityTest()
{
  // unity and zero tests
  CPPUNIT_ASSERT_EQUAL( true, zero.IsZero() );
  CPPUNIT_ASSERT_EQUAL( false, zero.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, unit.IsZero() );
  CPPUNIT_ASSERT_EQUAL( true, unit.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, notunit.IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, otherunit.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, otherunit.IsZero() );
};

/** UnitTest for Vector::CopyVector(), Vector::AddVector, Vector::SubtractVector() and Vector::Scale()/
 */
void VectorTest::SimpleAlgebraTest()
{
  double factor;
  // copy vector
  fixture = Vector(2.,3.,4.);
  CPPUNIT_ASSERT_EQUAL( Vector(2.,3.,4.), fixture );
  // summation and scaling
  fixture = zero + unit;
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
  fixture = zero - unit;
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsZero() );
  fixture = zero + zero;
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsZero() );
  fixture = notunit - otherunit;
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
  fixture = unit - otherunit;
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsOne() );
  fixture = notunit - unit - otherunit;
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsZero() );
  fixture = 0.98 * unit;
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsOne() );
  fixture = 1. * unit;
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
  factor = 0.98;
  fixture = factor * unit;
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsOne() );
  factor = 1.;
  fixture = factor * unit;
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
};


/** UnitTest for operator versions of Vector::CopyVector(), Vector::AddVector, Vector::SubtractVector() and Vector::Scale().
 */
void VectorTest::OperatorAlgebraTest()
{
  // summation and scaling
  CPPUNIT_ASSERT_EQUAL( true, (zero+unit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, (zero+unit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, (zero-unit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, (zero-unit).IsZero() );
  CPPUNIT_ASSERT_EQUAL( true, (zero+zero).IsZero() );
  CPPUNIT_ASSERT_EQUAL( true, (notunit-otherunit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, (unit+otherunit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, (notunit-unit-otherunit).IsZero() );
  CPPUNIT_ASSERT_EQUAL( false, (unit*0.98).IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, (unit*1.).IsOne() );

  CPPUNIT_ASSERT_EQUAL( unit, (zero+unit) );
  CPPUNIT_ASSERT_EQUAL( Vector(0.,0.,1.), (notunit-otherunit) );
  CPPUNIT_ASSERT_EQUAL( Vector(-1, 0., 1.), (notunit-unit-otherunit) );
};

/** UnitTest for scalar products.
 */
void VectorTest::EuclidianScalarProductTest()
{
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(zero) );
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(unit) );
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(otherunit) );
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(notunit) );
  CPPUNIT_ASSERT_EQUAL( 1., unit.ScalarProduct(unit) );
  CPPUNIT_ASSERT_EQUAL( 0., otherunit.ScalarProduct(unit) );
  CPPUNIT_ASSERT_EQUAL( 0., otherunit.ScalarProduct(unit) );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.ScalarProduct(notunit) );
  CPPUNIT_ASSERT_EQUAL( 2., two.ScalarProduct(unit) );
  CPPUNIT_ASSERT_EQUAL( 1., two.ScalarProduct(otherunit) );
  CPPUNIT_ASSERT_EQUAL( 1., two.ScalarProduct(notunit) );
}

/** UnitTest for norms.
 */
void VectorTest::EuclidianNormTest()
{
  CPPUNIT_ASSERT_EQUAL( 0., zero.Norm() );
  CPPUNIT_ASSERT_EQUAL( 0., zero.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( 1., unit.Norm() );
  CPPUNIT_ASSERT_EQUAL( 1., unit.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.Norm() );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( 2., notunit.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( sqrt(2.), notunit.Norm() );
}

/** UnitTest for distances.
 */
void VectorTest::EuclidianDistancesTest()
{
  CPPUNIT_ASSERT_EQUAL( 1., zero.distance(unit) );
  CPPUNIT_ASSERT_EQUAL( sqrt(2.), otherunit.distance(unit) );
  CPPUNIT_ASSERT_EQUAL( sqrt(2.), zero.distance(notunit) );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.distance(notunit) );
  CPPUNIT_ASSERT_EQUAL( sqrt(5.), two.distance(notunit) );
}

/** UnitTest for angles.
 */
void VectorTest::EuclidianAnglesTest()
{
  CPPUNIT_ASSERT_EQUAL( M_PI, zero.Angle(unit) );
  CPPUNIT_ASSERT_EQUAL( 0., unit.Angle(unit) );
  CPPUNIT_ASSERT_EQUAL( true, fabs(M_PI/2. - otherunit.Angle(unit)) < MYEPSILON );
  CPPUNIT_ASSERT_EQUAL( true, fabs(M_PI/2. - unit.Angle(notunit)) < MYEPSILON );
  CPPUNIT_ASSERT_EQUAL( true, fabs(M_PI/4. - otherunit.Angle(notunit)) < MYEPSILON );
};

/** UnitTest for projections.
 */
void VectorTest::ProjectionTest()
{
  CPPUNIT_ASSERT_EQUAL( zero, zero.Projection(unit) );
  CPPUNIT_ASSERT_EQUAL( zero, otherunit.Projection(unit) );
  CPPUNIT_ASSERT_EQUAL( Vector(0.4,0.2,0.),  otherunit.Projection(two) );
  CPPUNIT_ASSERT_EQUAL( Vector(0.,1.,0.),  two.Projection(otherunit) );
};

/**
 * Unittest for operation with normals
 */
void VectorTest::NormalsTest(){
  Vector testVector;
  // the zero Vector should produce an error
  CPPUNIT_ASSERT(!testVector.GetOneNormalVector(zero));

  // first one-component system
  CPPUNIT_ASSERT(testVector.GetOneNormalVector(unit));
  CPPUNIT_ASSERT(testVector.ScalarProduct(unit) < MYEPSILON);

  // second one-component system
  CPPUNIT_ASSERT(testVector.GetOneNormalVector(otherunit));
  CPPUNIT_ASSERT(testVector.ScalarProduct(otherunit) < MYEPSILON);

  // first two-component system
  CPPUNIT_ASSERT(testVector.GetOneNormalVector(notunit));
  CPPUNIT_ASSERT(testVector.ScalarProduct(notunit) < MYEPSILON);

  // second two-component system
  CPPUNIT_ASSERT(testVector.GetOneNormalVector(two));
  CPPUNIT_ASSERT(testVector.ScalarProduct(two) < MYEPSILON);

  // three component system
  CPPUNIT_ASSERT(testVector.GetOneNormalVector(three));
  CPPUNIT_ASSERT(testVector.ScalarProduct(three) < MYEPSILON);
}

/** UnitTest for line intersections.
 */
void VectorTest::LineIntersectionTest()
{
  // plane at (0,0,0) normal to (1,0,0) cuts line from (0,0,0) to (2,1,0) at ???
  CPPUNIT_ASSERT_NO_THROW(fixture = Plane(unit, zero).GetIntersection(zero, two) );
  CPPUNIT_ASSERT_EQUAL( zero, fixture );

  // plane at (2,1,0) normal to (0,1,0) cuts line from (1,0,0) to (0,1,1) at ???
  CPPUNIT_ASSERT_NO_THROW(fixture = Plane(otherunit, two).GetIntersection( unit, notunit) );
  CPPUNIT_ASSERT_EQUAL( Vector(0., 1., 1.), fixture );

  // four vectors equal to zero
  CPPUNIT_ASSERT_THROW(fixture = GetIntersectionOfTwoLinesOnPlane(zero, zero, zero, zero), LinearDependenceException);
  //CPPUNIT_ASSERT_EQUAL( zero, fixture );

  // four vectors equal to unit
  CPPUNIT_ASSERT_THROW(fixture = GetIntersectionOfTwoLinesOnPlane(unit, unit, unit, unit), LinearDependenceException);
  //CPPUNIT_ASSERT_EQUAL( zero, fixture );

  // two equal lines
  CPPUNIT_ASSERT_NO_THROW(fixture = GetIntersectionOfTwoLinesOnPlane(unit, two, unit, two));
  CPPUNIT_ASSERT_EQUAL( unit, fixture );

  // line from (1,0,0) to (2,1,0) cuts line from (1,0,0) to (0,1,0) at ???
  CPPUNIT_ASSERT_NO_THROW( fixture = GetIntersectionOfTwoLinesOnPlane(unit, two, unit, otherunit) );
  CPPUNIT_ASSERT_EQUAL( unit, fixture );

  // line from (1,0,0) to (0,0,0) cuts line from (0,0,0) to (2,1,0) at ???
  CPPUNIT_ASSERT_NO_THROW( fixture = GetIntersectionOfTwoLinesOnPlane(unit, zero, zero, two) );
  CPPUNIT_ASSERT_EQUAL( zero, fixture );

  // line from (1,0,0) to (2,1,0) cuts line from (0,0,0) to (0,1,0) at ???
  CPPUNIT_ASSERT_NO_THROW(fixture = GetIntersectionOfTwoLinesOnPlane(unit, two, zero, otherunit) );
  CPPUNIT_ASSERT_EQUAL( Vector(0., -1., 0.), fixture );
};

/** UnitTest for vector rotations.
 */
void VectorTest::VectorRotationTest()
{
  fixture = Vector(-1.,0.,0.);

  // zero vector does not change
  fixture = RotateVector(zero,unit, 1.);
  CPPUNIT_ASSERT_EQUAL( zero, fixture );

  fixture = RotateVector(zero, two, 1.);
  CPPUNIT_ASSERT_EQUAL( zero,  fixture);

  // vector on axis does not change
  fixture = RotateVector(unit,unit, 1.);
  CPPUNIT_ASSERT_EQUAL( unit, fixture );

  // rotations
  fixture = RotateVector(otherunit, unit, M_PI);
  CPPUNIT_ASSERT_EQUAL( Vector(0.,-1.,0.), fixture );

  fixture = RotateVector(otherunit, unit, 2. * M_PI);
  CPPUNIT_ASSERT_EQUAL( otherunit, fixture );

  fixture = RotateVector(otherunit,unit, 0);
  CPPUNIT_ASSERT_EQUAL( otherunit, fixture );

  fixture = RotateVector(Vector(0.,0.,1.), notunit, M_PI);
  CPPUNIT_ASSERT_EQUAL( otherunit, fixture );
}

/**
 * UnitTest for Vector::IsInParallelepiped().
 */
void VectorTest::IsInParallelepipedTest()
{
  double parallelepiped[NDIM*NDIM];
  parallelepiped[0] = 1;
  parallelepiped[1] = 0;
  parallelepiped[2] = 0;
  parallelepiped[3] = 0;
  parallelepiped[4] = 1;
  parallelepiped[5] = 0;
  parallelepiped[6] = 0;
  parallelepiped[7] = 0;
  parallelepiped[8] = 1;

  fixture = zero;
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
  fixture = Vector(2.5,2.5,2.5);
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
  fixture = Vector(1.,1.,1.);
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
  fixture = Vector(3.5,3.5,3.5);
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
  fixture = Vector(2.,2.,2.);
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
  fixture = Vector(2.,3.,2.);
  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
  fixture = Vector(-2.,2.,-1.);
  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
}