12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added remaining VectorValuesUnordered unit tests

release/4.3a0
Richard Roberts 2013-07-12 22:27:49 +00:00
parent a42cc71257
commit ae66a0468b
1 changed files with 67 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
gtsam/linear/tests/testVectorValuesUnordered.cpp
View File

@ -27,7 +27,9 @@ using namespace boost::assign;
using namespace gtsam; using namespace gtsam;
/* ************************************************************************* */ /* ************************************************************************* */
TEST(VectorValues, insert) { TEST(VectorValuesUnordered, basics)
{
// Tests insert(), size(), dim(), exists(), vector()
// insert // insert
VectorValuesUnordered actual; VectorValuesUnordered actual;
@ -37,7 +39,7 @@ TEST(VectorValues, insert) {
actual.insert(2, Vector_(2, 4.0, 5.0)); actual.insert(2, Vector_(2, 4.0, 5.0));
// Check dimensions // Check dimensions
LONGS_EQUAL(6, actual.size()); LONGS_EQUAL(4, actual.size());
LONGS_EQUAL(1, actual.dim(0)); LONGS_EQUAL(1, actual.dim(0));
LONGS_EQUAL(2, actual.dim(1)); LONGS_EQUAL(2, actual.dim(1));
LONGS_EQUAL(2, actual.dim(2)); LONGS_EQUAL(2, actual.dim(2));
@ -57,7 +59,7 @@ TEST(VectorValues, insert) {
EXPECT(assert_equal(Vector_(2, 2.0, 3.0), actual[1])); EXPECT(assert_equal(Vector_(2, 2.0, 3.0), actual[1]));
EXPECT(assert_equal(Vector_(2, 4.0, 5.0), actual[2])); EXPECT(assert_equal(Vector_(2, 4.0, 5.0), actual[2]));
EXPECT(assert_equal(Vector_(2, 6.0, 7.0), actual[5])); EXPECT(assert_equal(Vector_(2, 6.0, 7.0), actual[5]));
EXPECT(assert_equal(Vector_(7, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0), actual.asVector())); EXPECT(assert_equal(Vector_(7, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0), actual.vector()));
// Check exceptions // Check exceptions
CHECK_EXCEPTION(actual.insert(1, Vector()), invalid_argument); CHECK_EXCEPTION(actual.insert(1, Vector()), invalid_argument);
@ -65,7 +67,8 @@ TEST(VectorValues, insert) {
} }
/* ************************************************************************* */ /* ************************************************************************* */
TEST(VectorValues, combine) { TEST(VectorValuesUnordered, combine)
{
VectorValuesUnordered expected; VectorValuesUnordered expected;
expected.insert(0, Vector_(1, 1.0)); expected.insert(0, Vector_(1, 1.0));
expected.insert(1, Vector_(2, 2.0, 3.0)); expected.insert(1, Vector_(2, 2.0, 3.0));
@ -86,19 +89,73 @@ TEST(VectorValues, combine) {
} }
/* ************************************************************************* */ /* ************************************************************************* */
TEST(VectorValues, subvector) { TEST(VectorValuesUnordered, subvector)
{
VectorValuesUnordered init; VectorValuesUnordered init;
init.insert(0, Vector_(1, 1.0)); init.insert(10, Vector_(1, 1.0));
init.insert(1, Vector_(2, 2.0, 3.0)); init.insert(11, Vector_(2, 2.0, 3.0));
init.insert(2, Vector_(2, 4.0, 5.0)); init.insert(12, Vector_(2, 4.0, 5.0));
init.insert(3, Vector_(2, 6.0, 7.0)); init.insert(13, Vector_(2, 6.0, 7.0));
std::vector<Key> keys; std::vector<Key> keys;
keys += 0, 2, 3; keys += 10, 12, 13;
Vector expSubVector = Vector_(5, 1.0, 4.0, 5.0, 6.0, 7.0); Vector expSubVector = Vector_(5, 1.0, 4.0, 5.0, 6.0, 7.0);
EXPECT(assert_equal(expSubVector, init.vector(keys))); EXPECT(assert_equal(expSubVector, init.vector(keys)));
} }
/* ************************************************************************* */
TEST(VectorValuesUnordered, LinearAlgebra)
{
VectorValuesUnordered test1;
test1.insert(0, Vector_(1, 1.0));
test1.insert(1, Vector_(2, 2.0, 3.0));
test1.insert(5, Vector_(2, 6.0, 7.0));
test1.insert(2, Vector_(2, 4.0, 5.0));
VectorValuesUnordered test2;
test2.insert(0, Vector_(1, 6.0));
test2.insert(1, Vector_(2, 1.0, 6.0));
test2.insert(5, Vector_(2, 4.0, 3.0));
test2.insert(2, Vector_(2, 1.0, 8.0));
// Dot product
double dotExpected = test1.vector().dot(test2.vector());
double dotActual = test1.dot(test2);
DOUBLES_EQUAL(dotExpected, dotActual, 1e-10);
// Norm
double normExpected = test1.vector().norm();
double normActual = test1.norm();
DOUBLES_EQUAL(normExpected, normActual, 1e-10);
// Squared norm
double sqNormExpected = test1.vector().norm();
double sqNormActual = test1.norm();
DOUBLES_EQUAL(sqNormExpected, sqNormActual, 1e-10);
// Addition
Vector sumExpected = test1.vector() + test2.vector();
VectorValuesUnordered sumActual = test1 + test2;
EXPECT(sumActual.hasSameStructure(test1));
EXPECT(assert_equal(sumExpected, sumActual.vector()));
Vector sum2Expected = sumActual.vector() + test1.vector();
VectorValuesUnordered sum2Actual = sumActual;
sum2Actual += test1;
EXPECT(assert_equal(sum2Expected, sum2Actual.vector()));
// Subtraction
Vector difExpected = test1.vector() - test2.vector();
VectorValuesUnordered difActual = test1 - test2;
EXPECT(difActual.hasSameStructure(test1));
EXPECT(assert_equal(difExpected, difActual.vector()));
// Scaling
Vector scalExpected = test1.vector() * 5.0;
VectorValuesUnordered scalActual = test1;
scalActual *= 5.0;
EXPECT(assert_equal(scalExpected, scalActual.vector()));
}
/* ************************************************************************* */ /* ************************************************************************* */
int main() { TestResult tr; return TestRegistry::runAllTests(tr); } int main() { TestResult tr; return TestRegistry::runAllTests(tr); }
/* ************************************************************************* */ /* ************************************************************************* */