Add methods for getting per-cell part indexes

- add `CoclusteringCell.get_part_indexes_for_dimensions` to get the part
  indexes of the current cell instance, for the specified list of
  dimensions;
- add `CoclusteringDimension.get_part_indexes_of_cells` to get the part
  indexes of the specified cells, for the current dimension instance;
- add `CoclusteringReport.get_cell_part_indexes` to get the part indexes
  for all dimensions, for each cell;
- add `CoclusteringReport.get_per_dimension_cell_part_indexes` to get
  the part indexes of each cell, for each dimension; returns the
  transposition of the return value of the
  `CoclusteringReport.get_cell_part_indexes` method.

Author: popescu-v

khiops/core/coclustering_results.py

@@ -488,21 +488,44 @@ def get_dimension(self, dimension_name):
         """
         return self._dimensions_by_name[dimension_name]
 
+    def get_cell_part_indexes(self):
+        """Returns all cell part indexes
+
+        Returns
+        -------
+        list of list of int
+            The list of lists of cell part indexes for all dimensions, for each
+            cell.
+        """
+        cell_part_indexes = []
+        for cell in self.cells:
+            cell_part_indexes.append(
+                cell.get_part_indexes_for_dimensions(self.dimensions)
+            )
+        return cell_part_indexes
+
+    def get_per_dimension_cell_part_indexes(self):
+        """Returns per-dimension part indexes for all cells
+
+        Returns
+        -------
+        list of list of int
+            The list of lists of cell part indexes for for all cells, for each
+            dimension.
+
+        .. note::
+            The result of this method is the transposition of the return value
+            of the `get_cell_part_indexes` method.
+        """
+        per_dimension_part_indexes = []
+        for dimension in self.dimensions:
+            per_dimension_part_indexes.append(
+                dimension.get_part_indexes_of_cells(self.cells)
+            )
+        return per_dimension_part_indexes
+
     def to_dict(self):
         """Transforms this instance to a dict with the Khiops JSON file structure"""
-        # Compute cellPartIndexes
-        cell_parts_indexes = []
-        for cell in self.cells:
-            cell_part_indexes = []
-            for cell_part in cell.parts:
-                for dimension in self.dimensions:
-                    for dimension_part_index, dimension_part in enumerate(
-                        dimension.parts
-                    ):
-                        if cell_part == dimension_part:
-                            cell_part_indexes.append(dimension_part_index)
-                            break
-            cell_parts_indexes.append(cell_part_indexes)
         report_summary = {
             "instances": self.instance_number,
             "cells": self.cell_number,
@@ -532,7 +555,7 @@ def to_dict(self):
                 dimension.to_dict(report_type="hierarchy")
                 for dimension in self.dimensions
             ],
-            "cellPartIndexes": cell_parts_indexes,
+            "cellPartIndexes": self.get_cell_part_indexes(),
             "cellFrequencies": [cell.frequency for cell in self.cells],
         }
         return report
@@ -1075,6 +1098,24 @@ def get_part(self, part_name):
         """
         return self._parts_by_name[part_name]
 
+    def get_part_indexes_of_cells(self, cells):
+        """Returns part indexes of the specified cells, for the current dimension
+
+        Parameters
+        ----------
+        cells : list of `CoclusteringCell`
+
+        Returns
+        -------
+        list of list of int
+            The list of list of part indexes of the specified cells, for all
+            parts of the current dimension.
+        """
+        part_indexes = []
+        for cell in cells:
+            part_indexes.extend(cell.get_part_indexes_for_dimensions([self]))
+        return part_indexes
+
     def get_cluster(self, cluster_name):
         """Returns the specified cluster
 
@@ -1862,6 +1903,29 @@ def __init__(self):
         self.parts = []
         self.frequency = 0
 
+    def get_part_indexes_for_dimensions(self, dimensions):
+        """Returns cell part indexes for the specified dimensions
+
+        Parameters
+        ----------
+        dimensions : list of `CoclusteringDimension`
+            List of coclustering dimensions for which the cell part indexes must
+            be determined.
+
+        Returns
+        -------
+        list of int
+            The list of the cell  part indexes for the specified dimensions.
+        """
+        part_indexes = []
+        for part in self.parts:
+            for dimension in dimensions:
+                for dimension_part_index, dimension_part in enumerate(dimension.parts):
+                    if part == dimension_part:
+                        part_indexes.append(dimension_part_index)
+                        break
+        return part_indexes
+
     def write_line(self, writer):  # pragma: no cover
         """Writes a line of the instance's report to a writer object
 

tests/test_core.py

@@ -34,6 +34,11 @@
 # pylint: disable=protected-access
 
 
+def _transpose(a_list):
+    """Returns the transposition of a list of lists"""
+    return [list(x) for x in zip(*a_list)]
+
+
 class KhiopsCoreIOTests(unittest.TestCase):
     """Tests the reading/writing of files for the core module classes/functions"""
 
@@ -196,6 +201,14 @@ def test_coclustering_results(self):
                     results, ref_json_report
                 )
 
+                # Test that get_per_dimension_cell_part_indexes is the
+                # transposition of get_cell_part_indexes
+                report = results.coclustering_report
+                self.assertEqual(
+                    report.get_per_dimension_cell_part_indexes(),
+                    _transpose(report.get_cell_part_indexes()),
+                )
+
     def test_binary_dictionary_domain(self):
         """Test binary dictionary write"""
         # Set the test paths