test_vector.cxx

InsightToolkit-1.4.0(有大量的优化算法程序)

// This is core/vnl/tests/test_vector.cxx
#include <vcl_iostream.h>
#include <vnl/vnl_math.h>
#include <vnl/vnl_vector.h>
#include <vnl/vnl_matrix.h>
#include <vnl/vnl_cross.h>
#include <testlib/testlib_test.h>

void vnl_vector_test_int()
{
  vcl_cout << "***********************\n"
           << "Testing vnl_vector<int>\n"
           << "***********************\n";
  //// test constructors, accessors
  vnl_vector<int> v0;
  TEST("vnl_vector<int> v0()", v0.size(), 0);
  vnl_vector<int> v1(2);
  TEST("vnl_vector<int> v1(2)", v1.size(), 2);
  vnl_vector<int> v2(2,2);
  TEST("vnl_vector<int> v2(2,2)", (v2.get(0)==2 && v2.get(1)==2), true);
//   TEST("v0.set_compare", (v0.set_compare(int_equal), true), true);
  int vcvalues[] = {1,0};
  vnl_vector<int> vc(2,2,vcvalues);
  TEST("vnl_vector<int> vc(2,2,int[])", (vc(0)==1 && vc(1)==0), true);
  TEST("v1=2", (v1=2, (v1.get(0)==2 && v1.get(1)==2)), true);
  TEST("v1 == v2", (v1 == v2), true);
  TEST("v0 = v2", ((v0 = v2), (v0 == v2)), true);
  TEST("v2.put(1,3)", (v2.put(1,3),v2.get(1)), 3);
  TEST("v2.get(1)", v2.get(1), 3);
  TEST("v0 == v2", (v0 == v2), false);
  TEST("v0 != v2", (v0 != v2), true);
  TEST("(v0 == v2)", (v0 == v2), false);
  TEST("v1.fill(3)", (v1.fill(3), (v1.get(0)==3 && v1.get(1)==3)), true);
  TEST("v2.fill(2)", (v2.fill(2), (v2.get(0)==2 && v2.get(1)==2)), true);
  int v3values [] = {1,2,3};
  vnl_vector<int> v3(3,3,v3values);
  TEST("v3(3,3,{1,2,3})",(v3.get(0)==1 && v3.get(1)==2 && v3.get(2)==3), true);
  vnl_vector<int> v4(v3);
  TEST("vnl_vector<int> v4(v3)", v3, v4);
  TEST("v0=v2", (v0=v2, v0), v2);

  //// test additions and substractions
  TEST("v0=v2+3", ((v0=v2+3), (v0.get(0)==5 && v0.get(1)==5)), true);
  TEST("v0=3+v2", ((v0=3+v2), (v0.get(0)==5 && v0.get(1)==5)), true);
  TEST("v0+=(-3)", (v0+=(-3), (v0.get(0)==2 && v0.get(1)==2)), true);
  TEST("v0-=(-3)", (v0-=(-3), (v0.get(0)==5 && v0.get(1)==5)), true);
  TEST("v0=v2-3", ((v0=v2-3), (v0.get(0)==-1 && v0.get(1)==-1)), true);
  TEST("v0=3-v2", ((v0=3-v2), (v0.get(0)==1 && v0.get(1)==1)), true);
  TEST("v0= -v2", (v0= -v2, (v0.get(0)==-2 && v0.get(1)==-2)), true);

  vnl_vector<int> v5(2);
  v0 = v2;
  TEST("v5=v0+v2", ((v5=v0+v2), (v5.get(0)==4 && v5.get(1)==4)), true);
  TEST("v5=v0-v2", ((v5=v0-v2), (v5.get(0)==0 && v5.get(1)==0)), true);
  TEST("v0+=v2", ((v0+=v2), (v0.get(0)==4 && v0.get(1)==4)), true);
  TEST("v0-=v2", ((v0-=v2), (v0.get(0)==2 && v0.get(1)==2)), true);

  //// test multiplications and divisions
  TEST("v4=v3*5", ((v4=v3*5), (v4.get(0)==5 && v4.get(1)==10 && v4.get(2)==15)), true);

  TEST("v4=5*v3", ((v4=5*v3), (v4.get(0)==5 && v4.get(1)==10 && v4.get(2)==15)), true);
  TEST("v3*=5",((v3*=5), (v3== v4)), true);
  TEST("v4=v3/5", ((v4=v3/5), (v4.get(0)==1 && v4.get(1)==2 && v4.get(2)==3)), true);
  TEST("v3/=5", ((v3/=5), (v3==v4)), true);

  //// additional tests
  int vvalues [] = {0,-2,2,0};
  vnl_vector<int> v(4,4,vvalues);
  v0 = v; v1 = v; v2 = v;
  TEST("v(i)", (v(0)==0 && v(1)==-2 && v(2)==2 && v(3)==0), true);
#if 0
  TEST("v.abs()",
       ((v1 = v.abs()),
        (v1(0)==0 && v1(1)==2 && v1(2)==2 && v1(3)==0)), true);
  TEST("v.sign()",
       ((v1 = v.sign()),
        (v1(0)==0 && v1(1)==-1 && v1(2)==1 && v1(3)==0)), true);
#endif
  TEST("element_product(v,v)",
       ((v1 = element_product(v,v)),
        (v1(0)==0 && v1(1)==4 && v1(2)==4 && v1(3)==0)), true);
  TEST("element_quotient(v,[2])",
       ((v2 = 2),
        (v1 = element_quotient(v,v2)),
        (v1(0)==0 && v1(1)==-1 && v1(2)==1 && v1(3)==0)), true);
#if 0
  TEST("v.update(v.abs())",
        ((v1 = v.abs()),
         (v2.update(v1)),
         (v2==v1)), true);
#endif
  TEST("v.extract(1,3)",
       ((v1 = v.extract(1,3)),
        (v1.size()==1 && v1(0)==v(3))), true);
  TEST("v.update([4],3)",
       ((v1=4),
        (v.update(v1,3)),
        (v(0)==0 && v(1)==-2 && v(2)==2 && v(3)==4)), true);

  {                                             // new scope to reuse variables
    int vvalues [] = {1,0,0,0};
    vnl_vector<int> v (4,4,vvalues);
    int v1values [] = {1,0,0};
    int v2values [] = {0,1,0};
    int v3values [] = {0,0,1};
    vnl_vector<int> v1(3,3,v1values);
    vnl_vector<int> v2(3,3,v2values);
    vnl_vector<int> v3(3,3,v3values);
    TEST("dot_product(v1,v2)",
         (dot_product(v1,v2)==0 && dot_product(v1,v3)==0 && dot_product(v2,v3)==0), true);
    TEST("dot_product(v1,v1)",
         (dot_product(v1,v1)==1 && dot_product(v2,v2)==1 && dot_product(v3,v3)==1), true);
    TEST("4d-v=3d-v", ((v = v3), v.size()==3 && v==v3), true);
    TEST("vnl_cross_3d(v1,v2)", vnl_cross_3d(v1,v2), v3);
    TEST("vnl_cross_3d(v2,v3)", vnl_cross_3d(v2,v3), v1);
    TEST("vnl_cross_3d(v1,v3)", vnl_cross_3d(v1,v3), -v2);
    vnl_vector<int> vv(2,0);
    v1 = vv; v1[0]=1;
    v2 = vv; v2[1]=1;
    TEST("vnl_cross_2d(v1,v2)", vnl_cross_2d(v1,v2)==1, true);
  }

  {
    int vvalues [] = {1, 2, 3};
    vnl_vector<int> v (3, 3, vvalues);
    vnl_matrix<int> m;
    m = outer_product(v, v);
    TEST("outer_product",
         (m(0,0)==1 && m(0,1)==2 && m(0,2)==3 &&
          m(1,0)==2 && m(1,1)==4 && m(1,2)==6 &&
          m(2,0)==3 && m(2,1)==6 && m(2,2)==9), true);
  }
  {
    int vvalues [] = {1,0,0,0};
    vnl_vector<int> v (4,4,vvalues);
    TEST("v.squared_magnitude", (v.squared_magnitude()==1), true);
    TEST("v.magnitude", (v.magnitude()==1), true);
    // normalize not sensible for ints
    //TEST("v.normalize", (v1 = 3 * v, v1.normalize(), v1), v);
  }
}


bool float_equal(const float& f1, const float& f2){
  return vcl_fabs(f1 - f2) < 1.0e-6;
}

void vnl_vector_test_float()
{
  vcl_cout << "*************************\n"
           << "Testing vnl_vector<float>\n"
           << "*************************\n";
  //// test constructors, accessors
  vnl_vector<float> v0;
  TEST("vnl_vector<float> v0()", v0.size(), 0);
  vnl_vector<float> v1(2);
  TEST("vnl_vector<float> v1(2)", v1.size(), 2);
  vnl_vector<float> v2(2,2);
  TEST("vnl_vector<float> v2(2,2)", (v2.get(0)==2 && v2.get(1)==2), true);
#if 0
  TEST("v0.set_compare", (v0.set_compare(float_equal), true), true);
#endif

  float vcvalues[2] = {1};
  vnl_vector<float> vc(2,2,vcvalues);
  TEST("vnl_vector<float> vc(2,2,float[])", (vc(0)==1 && vc(1)==0), true);
  TEST("v1=2", (v1=2, (v1.get(0)==2 && v1.get(1)==2)), true);
  TEST("v1 == v2", (v1 == v2), true);
  TEST("v0 = v2", ((v0 = v2), (v0 == v2)), true);
  TEST("v2.put(1,3)", (v2.put(1,3),v2.get(1)), 3);
  TEST("v2.get(1)", v2.get(1), 3);
  TEST("v0 == v2", (v0 == v2), false);
  TEST("v0 != v2", (v0 != v2), true);
  TEST("(v0 == v2)", (v0 == v2), false);
  TEST("v1.fill(3)", (v1.fill(3), (v1.get(0)==3 && v1.get(1)==3)), true);
  TEST("v2.fill(2)", (v2.fill(2), (v2.get(0)==2 && v2.get(1)==2)), true);
  vnl_vector<float> v3(3); v3[0]=1.f; v3[1]=2.f; v3[2]=3.f;
  TEST("v3(3)",(v3.get(0)==1 && v3.get(1)==2 && v3.get(2)==3), true);
  vnl_vector<float> v4(v3);
  TEST("vnl_vector<float> v4(v3)", v3, v4);
  TEST("v0=v2", (v0=v2, (v0==v2)), true);
  vcl_cout << &v0 << " == " << v0 << vcl_endl;
  TEST("<<", 1, 1);

  //// test additions and substractions
  TEST("v0=v2+3", ((v0=v2+3), (v0.get(0)==5 && v0.get(1)==5)), true);
  TEST("v0=3+v2", ((v0=3.0f+v2), (v0.get(0)==5 && v0.get(1)==5)), true);
  TEST("v0+=(-3)", (v0+=(-3), (v0.get(0)==2 && v0.get(1)==2)), true);
  TEST("v0-=(-3)", (v0-=(-3), (v0.get(0)==5 && v0.get(1)==5)), true);
  TEST("v0=v2-3", ((v0=v2-3), (v0.get(0)==-1 && v0.get(1)==-1)), true);
  TEST("v0=3-v2", ((v0=3.0f-v2), (v0.get(0)==1 && v0.get(1)==1)), true);
  TEST("v0= -v2", (v0= -v2, (v0.get(0)==-2 && v0.get(1)==-2)), true);

  vnl_vector<float> v5(2);
  v0 = v2;
  TEST("v5=v0+v2", ((v5=v0+v2), (v5.get(0)==4 && v5.get(1)==4)), true);
  TEST("v5=v0-v2", ((v5=v0-v2), (v5.get(0)==0 && v5.get(1)==0)), true);
  TEST("v0+=v2", ((v0+=v2), (v0.get(0)==4 && v0.get(1)==4)), true);
  TEST("v0-=v2", ((v0-=v2), (v0.get(0)==2 && v0.get(1)==2)), true);

  //// test multiplications and divisions
  TEST("v4=v3*5", ((v4=v3*5), (v4.get(0)==5 && v4.get(1)==10 && v4.get(2)==15)), true);

  TEST("v4=5*v3", ((v4=5.0f*v3), (v4.get(0)==5 && v4.get(1)==10 && v4.get(2)==15)), true);
  TEST("v3*=5",((v3*=5), (v3== v4)), true);
  TEST("v4=v3/5", ((v4=v3/5), (v4.get(0)==1 && v4.get(1)==2 && v4.get(2)==3)), true);
  TEST("v3/=5", ((v3/=5), (v3==v4)), true);

  //// additional tests
//  vnl_vector<float> v(4,4,0,-2,2,0); no var args with floats
  float vvalues [] = {0,-2,2,0};
  vnl_vector<float> v(4,4,vvalues);
  v[0] = 0;
  v[1] = -2;
  v[2] = 2;
  v[3] = 0;
  v0 = v; v1 = v; v2 = v;
  TEST("v(i)", (v(0)==0 && v(1)==-2 && v(2)==2 && v(3)==0), true);
#if 0
  TEST("v.abs()",
       ((v1 = v.abs()),
        (v1(0)==0 && v1(1)==2 && v1(2)==2 && v1(3)==0)), true);
  TEST("v.sign()",
       ((v1 = v.sign()),
        (v1(0)==0 && v1(1)==-1 && v1(2)==1 && v1(3)==0)), true);
#endif
  TEST("element_product(v,v)",
       ((v1 = element_product(v,v)),
        (v1(0)==0 && v1(1)==4 && v1(2)==4 && v1(3)==0)), true);
  TEST("element_quotient(v,[2])",
       ((v2 = 2),
        (v1 = element_quotient(v,v2)),
        (v1(0)==0 && v1(1)==-1 && v1(2)==1 && v1(3)==0)), true);
#if 0
  TEST("v.update(v.abs())",
       ((v1 = v.abs()),
        (v2.update(v1)),
        (v2==v1)), true);
#endif
  TEST("v.extract(1,3)",
       ((v1 = v.extract(1,3)),
        (v1.size()==1 && v1(0)==v(3))), true);
  TEST("v.update([4],3)",
       ((v1=4),
        (v.update(v1,3)),
        (v(0)==0 && v(1)==-2 && v(2)==2 && v(3)==4)), true);

  {                                             // new scope to reuse variables
    float vvalues [] = {1,0,0,0};
    vnl_vector<float> v (4,4,vvalues);
    v[0] = 1;
    v[1] = 0;
    v[2] = 0;
    v[3] = 0;
    TEST("v(i)",
         (v(0)==v[0] && v[0]==1 &&
          v(1)==v[1] && v[1]==0 &&
          v(2)==v[2] && v[2]==0 &&
          v(3)==v[3] && v[3]==0), true);
    vnl_vector<float> v1(3,0.f); v1[0] = 1.f;
    vnl_vector<float> v2(3,0.f); v2[1] = 1.f;
    vnl_vector<float> v3(3,0.f); v3[2] = 1.f;
    TEST("dot_product(v1,v2)",
         (dot_product(v1,v2)==0 && dot_product(v1,v3)==0 && dot_product(v2,v3)==0), true);
    TEST("4d-v=3d-v", ((v = v3), v.size()==3 && v==v3), true);
    TEST("vnl_cross_3d(v1,v2)", vnl_cross_3d(v1,v2), v3);
    TEST("vnl_cross_3d(v2,v3)", vnl_cross_3d(v2,v3), v1);
    TEST("vnl_cross_3d(v1,v3)", vnl_cross_3d(v1,v3), -v2);
    vnl_vector<float> vv(2,0);
    v1 = vv; v1[0]=1;
    v2 = vv; v2[1]=1;
    TEST("vnl_cross_2d(v1,v2)", vnl_cross_2d(v1,v2), 1);