now using the new version of jacobi_pd

Author: jewettaij

include/superpose3d.hpp

@@ -8,13 +8,15 @@
 #define _SUPERPOSE3D_HPP
 
 
-#include "matrix_alloc.hpp" //convenient allocation function for 2D arrays
-#include "peigencalc.hpp"   //calculate eigenvalues and eigenvectors
+#include "matrix_alloc_jpd.hpp" // Defines "Alloc2D()" and "Dealloc2D()"
+#include "peigencalc.hpp"       // Calculates eigenvalues and eigenvectors
 
 
 
 namespace superpose3d {
 
+using namespace matrix_alloc_jpd;
+
 // -----------------------------------------------------------
 // ------------------------ INTERFACE ------------------------
 // -----------------------------------------------------------
@@ -372,22 +374,22 @@ Alloc(size_t N) {
   aWeights = new Scalar [N];
   for (size_t i = 0; i < N; i++)
     aWeights[i] = 1.0 / N;
-  matrix_alloc::Alloc2D(3, 3, &R);
-  matrix_alloc::Alloc2D(N, 3, &aaXf_shifted);
-  matrix_alloc::Alloc2D(N, 3, &aaXm_shifted);
+  Alloc2D(3, 3, &R);
+  Alloc2D(N, 3, &aaXf_shifted);
+  Alloc2D(N, 3, &aaXm_shifted);
 }
 
 template<typename Scalar, typename ConstArrayOfCoords, typename ConstArray>
 void Superpose3D<Scalar, ConstArrayOfCoords, ConstArray>::
 Dealloc() {
   if (R)
-    matrix_alloc::Dealloc2D(&R);
+    Dealloc2D(&R);
   if (aWeights)
     delete [] aWeights;
   if (aaXf_shifted)
-    matrix_alloc::Dealloc2D(&aaXf_shifted);
+    Dealloc2D(&aaXf_shifted);
   if (aaXm_shifted)
-    matrix_alloc::Dealloc2D(&aaXm_shifted);
+    Dealloc2D(&aaXm_shifted);
 }
 
 // memory management: copy and move constructor, swap, and assignment operator:

tests/test_superpose3d.cpp

@@ -31,8 +31,11 @@
 #include <chrono>
 #include <random>
 
-#include "superpose3d.hpp"
+#include "superpose3d.hpp"      // Defines "Superpose3D"
+#include "matrix_alloc_jpd.hpp" // Defines "Alloc2D()" and "Dealloc2D()"
+
 using namespace superpose3d;
+using namespace matrix_alloc_jpd;
 
 
 int main(int argc, char **argv) {
@@ -61,11 +64,11 @@ int main(int argc, char **argv) {
     w[i] = 1.0 / n_points;
 
   // Allocate the immobile point cloud array (X) and fill it with coordinates
-  matrix_alloc::Alloc2D(n_points, 3, &X);
+  Alloc2D(n_points, 3, &X);
   // Allocate the mobile point cloud array (x) and fill it with coordinates
-  matrix_alloc::Alloc2D(n_points, 3, &x);
+  Alloc2D(n_points, 3, &x);
   // Allocate space for the transformed mobile point cloud
-  matrix_alloc::Alloc2D(n_points, 3, &xprime);
+  Alloc2D(n_points, 3, &xprime);
 
   int seed = std::chrono::system_clock::now().time_since_epoch().count();
   std::default_random_engine rand_generator(seed);
@@ -168,9 +171,9 @@ int main(int argc, char **argv) {
 
   } // for (i_cl = 0; i_cl < n_point_clouds; i_cl++)
 
-  matrix_alloc::Dealloc2D(&xprime);
-  matrix_alloc::Dealloc2D(&X);
-  matrix_alloc::Dealloc2D(&x);
+  Dealloc2D(&xprime);
+  Dealloc2D(&X);
+  Dealloc2D(&x);
   delete [] w;
 
   std::cout << "\n" << "test passed." << std::endl;