Merge branch 'main' into doc

Author: jbdurand

doc/Doxyfile

@@ -769,7 +769,7 @@ FILE_PATTERNS          =
 # be searched for input files as well.
 # The default value is: NO.
 
-RECURSIVE              = NO
+RECURSIVE              = YES
 
 # The EXCLUDE tag can be used to specify files and/or directories that should be
 # excluded from the INPUT source files. This way you can easily exclude a

doc/examples/clustering.ipynb

@@ -100,88 +100,94 @@ class DistanceMatrixWrap
     ostringstream os;
 
     int nb_cluster = len(clusters);
-    int* cluster_nb_pattern;
-    int** cluster_pattern;
+    int* cluster_nb_pattern = NULL;
+    int** cluster_pattern = NULL;
 
     boost::python::list l;
 
     cluster_nb_pattern = new int[nb_cluster];
     cluster_pattern = new int*[nb_cluster];
 
-    // Build dynamic 2D array
-    try
-      {
-        for (int i = 0; i < nb_cluster; i++)
-          {
-#ifdef DEBUG
-            cout << "Processing cluster " << i << endl;
-#endif            
-            extract<boost::python::list> x(clusters[i]);
-            
-            if (x.check()) {
-              l = x;
-              int nb_item = len(l);
-
-              cluster_nb_pattern[i] = nb_item;
-
-              cluster_pattern[i] = new int[nb_item];
-
-              for (int j = 0; j < cluster_nb_pattern[i]; j++)
-                {
-                  cluster_pattern[i][j] = extract<int> ((l)[j]);
-                }
-          } else {
-            status = false;
+    if (nb_cluster > 1) {
+      // Build dynamic 2D array
+      try
+        {
+          for (int i = 0; i < nb_cluster; i++)
+            {
+  #ifdef DEBUG
+              cout << "Processing cluster " << i << endl;
+  #endif            
+              extract<boost::python::list> x(clusters[i]);
+              
+              if (x.check()) {
+                l = x;
+                int nb_item = len(l);
+
+                cluster_nb_pattern[i] = nb_item;
+
+                cluster_pattern[i] = new int[nb_item];
+
+                for (int j = 0; j < cluster_nb_pattern[i]; j++)
+                  {
+                    cluster_pattern[i][j] = extract<int> ((l)[j]);
+                  }
+            } else {
+              status = false;
+            }
           }
         }
-      }
-    catch (...)
-      {
+      catch (...)
+        {
+          // Free memory
+          for (int i = 0; i < nb_cluster; i++)
+            delete[] cluster_pattern[i];
+
+          delete[] cluster_nb_pattern;
+          delete[] cluster_pattern;
+        }
+
+      if (status) {
+        ret = dm.partitioning(error, &os, nb_cluster, cluster_nb_pattern,
+            cluster_pattern);
+
         // Free memory
         for (int i = 0; i < nb_cluster; i++)
           delete[] cluster_pattern[i];
 
         delete[] cluster_nb_pattern;
         delete[] cluster_pattern;
-      }
-
-    if (status) {
-      ret = dm.partitioning(error, &os, nb_cluster, cluster_nb_pattern,
-          cluster_pattern);
+      }} else {
+        ret = dm.partitioning(error, &os, nb_cluster, cluster_nb_pattern,
+            cluster_pattern);
+            delete[] cluster_nb_pattern;
+          delete[] cluster_pattern;
+        }
 
-      // Free memory
-      for (int i = 0; i < nb_cluster; i++)
-        delete[] cluster_pattern[i];
+      if (!ret)
+        stat_tool::wrap_util::throw_error(error);
 
-      delete[] cluster_nb_pattern;
-      delete[] cluster_pattern;
+      return ret;
     }
 
-    if (!ret)
-      stat_tool::wrap_util::throw_error(error);
+    static std::string
+    hierarchical_clustering(const DistanceMatrix& dm, int ialgorithm,
+        int icriterion, const std::string path, int iformat)
+    {
+      StatError error;
+      ostringstream os;
+      hierarchical_strategy algorithm = hierarchical_strategy(ialgorithm);
+      linkage criterion = linkage(icriterion);
+      output_format format = output_format(iformat);
 
-    return ret;
-  }
+      bool ret;
 
-  static std::string
-  hierarchical_clustering(const DistanceMatrix& dm, int ialgorithm,
-       int icriterion, const std::string path, int iformat)
-  {
-    StatError error;
-    ostringstream os;
-    hierarchical_strategy algorithm = hierarchical_strategy(ialgorithm);
-    linkage criterion = linkage(icriterion);
-    output_format format = output_format(iformat);
-
-    bool ret;
-
-    ret = dm.hierarchical_clustering(error, &os, algorithm, criterion,
-                                     path, format);
+      ret = dm.hierarchical_clustering(error, &os, algorithm, criterion,
+                                      path, format);
 
-    if (!ret)
-      stat_tool::wrap_util::throw_error(error);
+      if (!ret)
+        stat_tool::wrap_util::throw_error(error);
 
-    return string(os.str());
+      return string(os.str());
 
   }
 
@@ -533,7 +539,6 @@ class DistanceMatrixWrap
   }
 
 
-
 };
 
 #define WRAP DistanceMatrixWrap
@@ -615,6 +620,31 @@ class_distance_matrix()
 #undef WRAP
 #undef CLASS
 
+class ClustersWrap
+{
+
+public:
+
+  static int
+  // Return cluster of an (individual ="pattern")
+  // Indices are between 1 and nb_pattern for individuals
+  // between 1 and nb_cluster for clusters
+  get_assignment(const Clusters &cluster, int pattern)
+  {
+    StatError error;
+
+    if ((0 < pattern) & (pattern <= cluster.get_nb_pattern()))
+      return cluster.get_assignment(pattern-1)+1;
+    else {
+      error.update(STAT_error[STATR_SAMPLE_INDEX]);
+      stat_tool::wrap_util::throw_error(error);   
+    }
+  }
+};
+
+#define WRAP ClustersWrap
+#define CLASS Clusters
+
 void
 class_cluster()
 {
@@ -623,8 +653,11 @@ class_cluster()
 
   .def(self_ns::str(self)) // __str__
 
-  ;
+  .def("get_nb_cluster", &CLASS::get_nb_cluster, "Return number of clusters")
+  .def("get_assignment", WRAP::get_assignment,
+      args("pattern"),"Get cluster of a vector (index between 0 and nb_pattern)")
 
+  ;
   /*
   Clusters();
      Clusters(const DistanceMatrix &dist_matrix , int inb_cluster ,
@@ -659,8 +692,13 @@ class_cluster()
      int get_pattern_length(int pattern , int cluster) const
      { return pattern_length[pattern][cluster]; }
      */
+
 }
 
+
+#undef WRAP
+#undef CLASS
+
 void
 class_dendrogram()
 {

src/wrapper/export_distance_matrix.cpp

@@ -18,7 +18,7 @@ test_distribution.py                    DONE
 test_error.py                           DONE
 test_estimate.py                        DONE
 test_histogram.py                       DONE
-test_matrix.py                          TOBECLEANED/FINALISED
+test_matrix.py                          DONE
 test_mixture_functional.py              DONE
 test_mixture.py                         DONE
 test_multivariate_mixture_functional.py DONE

test/README.md

@@ -57,6 +57,16 @@ int main(void) {
       delete [] cluster_pattern[1];
       if (error.get_nb_error() > 0)
         cout << error;
+      delete [] cluster_pattern;
+      delete [] cluster_nb_pattern;
+      cluster_pattern = new int*[1];
+      cluster_pattern[0] = new int[1];
+      cluster_pattern[0][0] = 0;
+      cluster_nb_pattern = new int[1];
+      cluster_nb_pattern[0] = 0;
+      clust = matrix10->partitioning(error, &cout, 1, cluster_nb_pattern,
+          cluster_pattern);
+      delete [] cluster_pattern[0];
     } else {
       cout << error;
     }

test/cpp/test_matrix.cpp

@@ -152,3 +152,7 @@ def test_clustering():
     assert str(c1) == str(matrix10.partitioning_prototype(3, [1, 3, 12], 1, 1))
     assert str(c1_bis) == str(matrix10.partitioning_prototype(3, [1, 3, 12], 1, 2))
 
+    c5 = Clustering(matrix10, "Partition", 2)
+    assert c5
+    assert c5.get_nb_cluster() == 2
+    c5.get_assignment(2) == 1

test/test_cluster.py

@@ -19,6 +19,7 @@
 
 @pytest.fixture
 def data():
+    # Inspired from stat_toot_test.aml
     vec10 = Vectors(get_shared_data("chene_sessile.vec"))
     vec15 = SelectVariable(vec10, [1, 3, 6], Mode="Reject")
     matrix10 = Compare(vec15, VectorDistance("N", "N", "N"))

test/test_distance_matrix.py

@@ -12,6 +12,7 @@
 from openalea.stat_tool.comparison import Compare
 from openalea.stat_tool.data_transform import SelectVariable
 from openalea.stat_tool.vectors import VectorDistance, Vectors
+from openalea.stat_tool.cluster import Clustering
 
 from pathlib import Path
 
@@ -71,7 +72,6 @@ def test_get_substitution_distance(data):
 def test_get_insertion_distance(data):
     assert data.get_insertion_distance(0,0) == -1
 
-# TODO: test_hierarchical_clustering
 def test_get_shape(data):
     assert (data.nb_column, data.nb_row) == (138, 138)
 
@@ -95,22 +95,35 @@ def test_select_individual(myi):
 def test_select_individual(myi):
     assert myi.data.select_individual([1], False)
 
-# def test_wrong_partitioning_clusters(myi):
-#   assert myi.data.partitioning_clusters([0])
+def test_wrong_partitioning_clusters(myi):
+    try:
+        myi.data.partitioning_clusters([0])
+        myi.data.partitioning_clusters([])
+        myi.data.partitioning_clusters([[1,2], [3,4]])
+        assert False
+    except:
+        assert True
 
 def test_partitioning_clusters(myi):
-   assert myi.data.partitioning_clusters([[1, 2], [3, 4]])
-
-def test_partitioning_prototype(myi):
-    # TODO: find a test that would make more sense
+   clust1 = Clustering(myi.data, "Partition", 2)
+   nb_clusters = clust1.get_nb_cluster()
+   # partition
+   part1 = [[i for i in range(1,myi.data.nb_row+1) if clust1.get_assignment(i) == c] for c in range(1,nb_clusters+1)]
+   assert myi.data.partitioning_clusters(part1)
+
+def test_wrong_partitioning_prototype(myi):
+    """
+    Testing errors in partitioning_prototype.
+    Other features of partitioning_prototype are tested in test_cluster.py
+    """
     try:
         assert myi.data.partitioning_prototype(0, [0], 0, 0)
         assert False
     except:
         assert True    
 
 
-def test_symmetrize(myi):
+def test_wrong_symmetrize(myi):
     try:
         myi.data.symmetrize()
         assert False
@@ -150,4 +163,5 @@ def data():
 
     test_get_column_identifier(data())
     test_select_individual(myi)
-    test_partitioning_clusters(myi)
+    test_partitioning_clusters(myi)
+    test_wrong_partitioning_clusters(myi)