Minor fix. Some wierd behavior observed in conda environment,

but it was due to a mixture of system library and conda library.
Clean installation of conda env and alamode solved the issue.

Author: ttadano

alm/cluster.cpp

@@ -161,32 +161,30 @@ void Cluster::init(const std::unique_ptr<System> &system, const std::unique_ptr<
 void Cluster::generate_unique_clusters(const size_t natmin, const std::vector<std::vector<int>> &map_p2s,
                                        std::vector<std::set<IntList>> &cluster_out) const
 {
-    int *pair_tmp;
+    std::vector<int> pair_vec;
 
     for (auto order = 0; order < maxorder; ++order) {
 
         cluster_out[order].clear();
 
-        allocate(pair_tmp, order + 2);
+        pair_vec.resize(order + 2);
 
         for (size_t i = 0; i < natmin; ++i) {
 
             const auto iat = map_p2s[i][0];
 
             for (const auto &it: interaction_cluster[order][i]) {
 
-                pair_tmp[0] = iat;
+                pair_vec[0] = iat;
                 for (auto j = 0; j < order + 1; ++j) {
-                    pair_tmp[j + 1] = it.atom[j];
+                    pair_vec[j + 1] = it.atom[j];
                 }
-                insort(order + 2, pair_tmp);
 
-                // Ignore many-body case
-                // if (!satisfy_nbody_rule(order + 2, pair_tmp, order)) continue;
-                cluster_out[order].insert(IntList(order + 2, pair_tmp));
+                // Use std::sort for deterministic, stable ordering across platforms
+                std::sort(pair_vec.begin(), pair_vec.end());
+                cluster_out[order].insert(IntList(pair_vec));
             }
         }
-        deallocate(pair_tmp);
     }
 }
 

alm/cluster.h

@@ -45,20 +45,24 @@ class IntList
         }
     }
 
+    // Constructor from std::vector for modern C++ style
+    explicit IntList(const std::vector<int> &vec) : iarray(vec)
+    {}
+    explicit IntList(std::vector<int> &&vec) : iarray(std::move(vec))
+    {}
+
     auto operator<(const IntList &a) const -> bool
     {
         return std::lexicographical_compare(iarray.begin(), iarray.end(), a.iarray.begin(), a.iarray.end());
     }
 
     auto operator==(const IntList &a) const -> bool
     {
-        const auto n = iarray.size();
-        const auto n_ = a.iarray.size();
-        if (n != n_) return false;
-        for (size_t i = 0; i < n; ++i) {
-            if (iarray[i] != a.iarray[i]) return false;
-        }
-        return true;
+        // Use vector's built-in equality operator for consistency
+        // This is required for std::unordered_set<IntList> in fcs.cpp
+        // and ensures consistent behavior across platforms
+        // std::cout << "== operator called\n";
+        return iarray == a.iarray;
     }
 };