merge

diff --cc TODO.txt
Simple merge

diff --cc sample/CMakeLists.txt
index e564b5f,85c602f..e0f712a
--- 1/sample/CMakeLists.txt
--- 2/sample/CMakeLists.txt
+++ b/sample/CMakeLists.txt
@@@ -12,10 -12,10 +12,10 @@@ link_directories("${PROJECT_SOURCE_DIR}
  
  # set compile flags
  if (MSVC)
-       set(CMAKE_CXX_FLAGS "/EHsc /nologo /W4 /WX")
+       set(CMAKE_CXX_FLAGS "/EHsc /nologo /W4")
  elseif (CMAKE_COMPILER_IS_GNUCC)
        set(CMAKE_CXX_FLAGS " -Wall -O3 -DNDEBUG -std=c++0x")
 -      #set(CMAKE_CXX_FLAGS "-Wall -Werror -g -DPSTSDK_VALIDATION_LEVEL_FULL -std=c++0x")
 +      #set(CMAKE_CXX_FLAGS "-Wall -g  -std=c++0x")
  endif()
  
  

diff --cc src/mof/math/basic_matrix.hpp
index 5f9cf06,13b9a43..06972ee
--- 1/src/mof/math/basic_matrix.hpp
--- 2/src/mof/math/basic_matrix.hpp
+++ b/src/mof/math/basic_matrix.hpp
@@@ -114,19 -107,33 +114,40 @@@ namespace mat
                }
  //}}}
  //{{{ operator *=     
 -              /**
 -               * @brief 行列の積を計算し，最後の要素が1になるように定数倍する．
 -               */
                Derived& operator*=(const Derived& rhs)
                {
++<<<<<<< HEAD
 +                      Derived M;
 +                      for (size_t i = 0; i < Dim; ++i) {
 +                              for (size_t j = 0; j <= Dim; ++j) {
 +                                      float sum = 0;
 +                                      for (size_t k = 0; k <= Dim; ++k) {
 +                                              sum += at(i, k) * rhs.at(k, j);
 +                                      }
 +                                      M.elements_[i][j] = sum;
++=======
+                       Derived retval;
+                       const int SIZE = Dim + 1;
+ 
+                       // calculate the last element previously
+                       int b = last_index() - Dim;
+                       int c = Dim;
+                       float last_sum = 0;
+                       for (int i = 0; i < SIZE; ++i) {
+                               last_sum += elements_[b + i] * rhs.elements_[c + i * SIZE];
+                       }
+                       retval.elements_[last_index()] = 1;
+ 
+                       for (int a = last_index() - 1; a >= 0; --a) {
+                               int b = a / SIZE * SIZE;
+                               int c = a % SIZE;
+                               float sum = 0;
+                               for (int i = 0; i < SIZE; ++i) {
+                                       sum += elements_[b + i] * rhs.elements_[c + i * SIZE];
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
                                }
 -                              retval.elements_[a] = sum / last_sum;
                        }
 -                      *this = retval;
 +                      *this = M;
                        return *reinterpret_cast<Derived*>(this);//thisがDerived型であることは保証されている．
                }
  

diff --cc src/mof/math/basic_vector.hpp
index 80e0410,8ac5baa..e6ae1a3
--- 1/src/mof/math/basic_vector.hpp
--- 2/src/mof/math/basic_vector.hpp
+++ b/src/mof/math/basic_vector.hpp
@@@ -86,13 -80,6 +86,16 @@@ namespace mat
                        for (size_t i = 0; i < Dim; ++i) components_[i] *= rhs;
                        return *reinterpret_cast<Derived*>(this);//thisがDerived型であることは保証されている．
                }
++<<<<<<< HEAD
 +              
 +              friend Derived operator*(float rhs1, Derived& rhs2)
 +              {
 +                      Derived retval;
 +                      for (size_t i = 0; i < Dim; ++i) retval.components_[i] = rhs1 * rhs2.components_[i];
 +                      return retval;
 +              }
++=======
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
  //}}}
  //{{{ operator /=
                Derived& operator/=(float rhs)

diff --cc src/mof/math/matrix2.hpp
index a460b76,541d39a..2e969de
--- 1/src/mof/math/matrix2.hpp
--- 2/src/mof/math/matrix2.hpp
+++ b/src/mof/math/matrix2.hpp
@@@ -66,8 -73,8 +66,13 @@@ namespace mat
  //{{{ operator =
        matrix2& operator = (const matrix2& rhs)
        {
++<<<<<<< HEAD
 +              for (size_t i = 0; i < size(); ++i) {
 +                      components_[i] = rhs.components_[i];
++=======
+               for (size_t i = 0; i <= last_index() - 1; ++i) {
+                       elements_[i] = rhs.elements_[i];
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
                }
                return *this;
        }

diff --cc src/mof/math/matrix3.hpp
index 77e6ade,3f5e14e..a6f7849
--- 1/src/mof/math/matrix3.hpp
--- 2/src/mof/math/matrix3.hpp
+++ b/src/mof/math/matrix3.hpp
@@@ -60,8 -67,8 +60,13 @@@ namespace mat
  //{{{ copy constructor
        matrix3(const matrix3& rhs)
        {
++<<<<<<< HEAD
 +              for (size_t i = 0; i < size(); ++i) {
 +                      components_[i] = rhs.components_[i];
++=======
+               for (size_t i = 0; i <= last_index(); ++i) {
+                       elements_[i] = rhs.elements_[i];
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
                }
        }
  //}}}
@@@ -71,8 -78,8 +76,13 @@@
         */
        matrix3& operator = (const matrix3& rhs)
        {
++<<<<<<< HEAD
 +              for (size_t i = 0; i < size(); ++i) {
 +                      components_[i] = rhs.components_[i];
++=======
+               for (size_t i = 0; i <= last_index() -1; ++i) {
+                       elements_[i] = rhs.elements_[i];
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
                }
                return *this;
        }

diff --cc src/mof/math/test/matrix3_test.cpp
index f079e11,67c4f17..30595a4
--- 1/src/mof/math/test/matrix3_test.cpp
--- 2/src/mof/math/test/matrix3_test.cpp
+++ b/src/mof/math/test/matrix3_test.cpp
@@@ -80,10 -94,11 +80,15 @@@ int main(
        }
  
        {
 -              matrix3 N1(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 0, 0);
 -              matrix3 N2(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0);
 +              matrix3 N1(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 +              matrix3 N2(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
                matrix3 N = N1 * N2;
++<<<<<<< HEAD
 +              matrix3 A(44, 50, 56, 66, 116, 134, 152, 178, 188, 218, 248, 290);
++=======
+               matrix3 A(44, 50, 56, 66, 116, 134, 152, 178, 188, 218, 248, 290, 0, 0, 0);
+               cout << N << endl;
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
                if (N != A) {
                        cerr << "Failed:" << "Affine matrix N1 * N2 test" << endl;      
                        failed_count++;
@@@ -91,10 -106,27 +96,31 @@@
        }
        
        {
++<<<<<<< HEAD
 +              matrix3 M(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
++=======
+               matrix3 N1(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+               matrix3 N2(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+               matrix3 N = N1 * N2;
+               matrix3 A
+               (
+                       0.25840f, 0.28424f, 0.31008f, 0.17054f,
+                       0.58915f, 0.65633f, 0.72351f, 0.45995f,
+                       0.91990f, 1.02842f, 1.13695f, 0.74935f,
+                       0.70801f, 0.81912f, 0.93023f
+               );
+               if (N != A) {
+                       cerr << "Failed:" << "Projective matrix N1 * N2 test" << endl;  
+                       failed_count++;
+               }
+       }
+       
+       {
+               matrix3 M(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
++>>>>>>> 01b4978a6b6cd046ad399644ea70ddec977a688a
                vector3 v(1, 2, 3);
                vector3 w = M * v;
 -              vector3 a(0.20690f, 0.52874f, 0.85057f);
 +              vector3 a(18, 46, 74);
                if (a != w) {
                        cerr << "Failed:" << "M * v test" << endl;      
                        failed_count++;