Merge remote-tracking branch 'upstream/master' into general-tensor-in…

…dices

.github/workflows/cmake.yml

@@ -31,7 +31,7 @@ jobs:
         -DBUILD_SHARED_LIBS=OFF
         -DCMAKE_UNITY_BUILD=${{ matrix.build_type == 'Debug' }}
         -DMPIEXEC_PREFLAGS='--bind-to;none;--allow-run-as-root'
-        -DCMAKE_PREFIX_PATH='/usr/local/opt/boost@1.76'
+        -DCMAKE_PREFIX_PATH='/usr/local/opt/boost'
         -DSEQUANT_EVAL_TESTS=ON
         -DSEQUANT_USE_SYSTEM_BOOST_HASH=OFF
         -DCMAKE_CXX_STANDARD=20
@@ -47,7 +47,7 @@ jobs:
 
     - name: Install prerequisite MacOS packages
       if: ${{ matrix.os == 'macos-latest' }}
-      run: brew install ninja gcc@10 boost@1.76 eigen open-mpi ccache
+      run: brew install ninja boost eigen open-mpi ccache catch2
 
     - name: Install prerequisites Ubuntu packages
       if: ${{ matrix.os == 'ubuntu-22.04' }}

.github/workflows/formatting_check.yml

@@ -0,0 +1,15 @@
+name: Formatting check
+
+on: [push, pull_request]
+
+jobs:
+  check:
+    name: "Check formatting"
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: jidicula/[email protected]
+        with:
+          clang-format-version: "17"
+          exclude-regex: "/SeQuant\\/external/"
+

CMakeLists.txt

@@ -148,6 +148,9 @@ include(FindOrFetchRangeV3)
 # Boost will be added after defining SeQuant
 include(external/boost.cmake)
 
+# LibPerm
+include(FindOrFetchLibPerm)
+
 # embedded bliss-0.73
 add_library(SeQuant-bliss
         SeQuant/external/bliss/defs.cc
@@ -395,6 +398,9 @@ include(CTest)
 
 if (BUILD_TESTING)
 
+    # need catch2
+    include(FindOrFetchCatch2)
+
     set(utests_src
             tests/unit/test_space.cpp
             tests/unit/test_index.cpp
@@ -434,12 +440,11 @@ if (BUILD_TESTING)
                 tests/unit/test_eval_btas.cpp tests/unit/test_eval_ta.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
     endif (TARGET tiledarray)
 
-    set(utests_deps SeQuant)
+    set(utests_deps SeQuant Catch2::Catch2)
 
     set(unit_test_executable unit_tests-sequant)
     add_executable(${unit_test_executable} EXCLUDE_FROM_ALL
             tests/unit/test_main.cpp
-            tests/unit/catch.hpp
             tests/unit/test_config.hpp
             ${utests_src})
     target_link_libraries(${unit_test_executable} ${utests_deps})

SeQuant/core/any.hpp

@@ -17,8 +17,8 @@
 #define SEQUANT_HAS_CXX17_ANY
 #endif  //  10.14 or later
 #endif  // have macos version
-//#else   // libc++ on macos
-//#define SEQUANT_HAS_CXX17_ANY
+// #else   // libc++ on macos
+// #define SEQUANT_HAS_CXX17_ANY
 #endif  // libc++ on macos
 #endif  // c++17
 

SeQuant/core/asy_cost.cpp

@@ -155,12 +155,12 @@ AsyCost const &AsyCost::zero() {
   return zero;
 }
 
-AsyCost& AsyCost::operator+=(AsyCost const& other) {
+AsyCost &AsyCost::operator+=(AsyCost const &other) {
   *this = *this + other;
   return *this;
 }
 
-AsyCost& AsyCost::operator-=(AsyCost const& other) {
+AsyCost &AsyCost::operator-=(AsyCost const &other) {
   *this = *this - other;
   return *this;
 }
@@ -226,11 +226,11 @@ bool operator>(AsyCost const &lhs, AsyCost const &rhs) {
   return !(lhs < rhs || lhs == rhs);
 }
 
-bool operator<=(AsyCost const& lhs, AsyCost const& rhs) {
+bool operator<=(AsyCost const &lhs, AsyCost const &rhs) {
   return lhs < rhs || lhs == rhs;
 }
 
-bool operator>=(AsyCost const& lhs, AsyCost const& rhs) {
+bool operator>=(AsyCost const &lhs, AsyCost const &rhs) {
   return lhs > rhs || lhs == rhs;
 }
 

SeQuant/core/complex.hpp

@@ -44,9 +44,11 @@ struct Complex {
     std::wstring result = L"{";
     result += to_latex(this->real());
     if (this->imag() > 0) {
-      result = L"\\bigl(" + result + L" + i " + to_latex(this->imag()) + L"\\bigr)";
+      result =
+          L"\\bigl(" + result + L" + i " + to_latex(this->imag()) + L"\\bigr)";
     } else if (this->imag() < 0)
-      result = L"\\bigl(" + result + L" - i " + to_latex(-this->imag()) + L"\\bigr)";
+      result =
+          L"\\bigl(" + result + L" - i " + to_latex(-this->imag()) + L"\\bigr)";
     result += L"}";
     return result;
   }

SeQuant/core/context.cpp

@@ -1,5 +1,5 @@
-#include <SeQuant/core/context.hpp>
 #include <SeQuant/core/attr.hpp>
+#include <SeQuant/core/context.hpp>
 #include <SeQuant/core/utility/context.hpp>
 
 namespace sequant {

SeQuant/core/eval_expr.cpp

@@ -1,14 +1,14 @@
-#include <SeQuant/core/eval_expr.hpp>
 #include <SeQuant/core/attr.hpp>
 #include <SeQuant/core/complex.hpp>
 #include <SeQuant/core/container.hpp>
 #include <SeQuant/core/context.hpp>
+#include <SeQuant/core/eval_expr.hpp>
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/hash.hpp>
 #include <SeQuant/core/index.hpp>
 #include <SeQuant/core/tensor.hpp>
-#include <SeQuant/core/wstring.hpp>
 #include <SeQuant/core/utility/indices.hpp>
+#include <SeQuant/core/wstring.hpp>
 
 #include <range/v3/action.hpp>
 #include <range/v3/algorithm.hpp>
@@ -18,14 +18,14 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <iterator>
 #include <memory>
 #include <string_view>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
-#include <cmath>
-#include <tuple>
 
 namespace sequant {
 
@@ -45,29 +45,53 @@ std::wstring_view const var_label = L"Z";
 
 }  // namespace
 
-template <
-    typename Iterable,
-    std::enable_if_t<!std::is_same_v<InnerOuterIndices, std::decay_t<Iterable>>,
-                     bool> = true>
-std::string indices_to_annot(Iterable const& indices) noexcept {
-  using ranges::views::intersperse;
-  using ranges::views::join;
-  using ranges::views::transform;
+NestedTensorIndices::NestedTensorIndices(const sequant::Tensor& tnsr) {
+  auto push_ix = [this](Index const& ix) {
+    if (ix.has_proto_indices())
+      inner.push_back(ix);
+    else
+      outer.push_back(ix);
+  };
 
-  auto idx_label = [](Index const& idx) { return to_string(idx.label()); };
+  for (auto const& ix : tnsr.const_braket()) {
+    push_ix(ix);
+    for (auto const& ix_proto : ix.proto_indices()) push_ix(ix_proto);
+  }
 
-  return indices | transform(idx_label) | intersperse(",") | join |
-         ranges::to<std::string>;
+  if (!inner.empty()) {
+    ranges::actions::stable_sort(outer, Index::LabelCompare{});
+    ranges::actions::unique(outer, [](Index const& ix1, Index const& ix2) {
+      return ix1.label() == ix2.label();
+    });
+  }
 }
 
-std::string indices_to_annot(InnerOuterIndices const& inout) noexcept {
-  auto const& in = inout.inner;
-  auto const& out = inout.outer;
-  if (out.empty()) {
-    return indices_to_annot(in);
-  } else {
-    return indices_to_annot(in) + ";" + indices_to_annot(out);
-  }
+std::string EvalExpr::braket_annot() const noexcept {
+  if (!is_tensor()) return {};
+
+  // given an iterable of sequant::Index objects, returns a string made
+  // of their full labels separated by comma
+  //   eg. (a_1^{i_1,i_2},a_2^{i_2,i_3}) -> "a_1i_1i_2,a_2i_2i_3"
+  //   eg. (i_1, i_2) -> "i_1,i_2"
+  auto annot = [](auto&& ixs) -> std::string {
+    using namespace ranges::views;
+
+    auto full_labels = ixs                              //
+                       | transform(&Index::full_label)  //
+                       | transform([](auto&& fl) {      //
+                           return sequant::to_string(fl);
+                         });
+    return full_labels                      //
+           | intersperse(std::string{","})  //
+           | join                           //
+           | ranges::to<std::string>;
+  };
+
+  auto nested = NestedTensorIndices{as_tensor()};
+
+  return nested.inner.empty()  //
+             ? annot(nested.outer)
+             : annot(nested.outer) + ";" + annot(nested.inner);
 }
 
 size_t EvalExpr::global_id_{};
@@ -145,29 +169,9 @@ Variable const& EvalExpr::as_variable() const noexcept {
   return expr().as<Variable>();
 }
 
-InnerOuterIndices EvalExpr::inner_outer_indices() const noexcept {
-  if (is_scalar()) return {};
-
-  assert(is_tensor());
-  auto const& t = expr()->as<Tensor>();
-
-  container::svector<Index> inner;
-  container::svector<Index> outer;
-  for (auto const& idx : t.const_indices()) {
-    inner.emplace_back(idx);
-    for (auto const& pidx : idx.proto_indices()) outer.emplace_back(pidx);
-  }
-  ranges::stable_sort(outer, Index::LabelCompare{});
-  ranges::actions::unique(outer);
-  ranges::actions::remove_if(
-      inner, [&outer](Index const& i) { return ranges::contains(outer, i); });
-  return {std::move(inner), std::move(outer)};
-}
-
 std::string EvalExpr::label() const noexcept {
   if (is_tensor())
-    return to_string(as_tensor().label()) + "(" +
-           indices_to_annot(inner_outer_indices()) + ")";
+    return to_string(as_tensor().label()) + "(" + braket_annot() + ")";
   else if (is_constant()) {
     auto const& c = as_constant();
     auto real = Constant{c.value().real()}.value<double>();

SeQuant/core/eval_expr.hpp

@@ -47,19 +47,19 @@ enum class EvalOp {
 enum class ResultType { Tensor, Scalar };
 
 ///
-/// @see EvalExpr::inner_outer_indices
+/// \brief Represents the outer indices and the inner indices of a nested
+/// tensor.
 ///
-struct InnerOuterIndices {
-  container::svector<Index> const inner;
-  container::svector<Index> const outer;
-};
-
-///
-/// \param inout InnerOuterIndices object.
-/// \return String of comma-separated labels of inner indices followed by the
-///         labels of outer indices, separated by a semicolon.
+/// \note The nested tensor is a concept that generalizes the sequant::Tensor
+/// with and without proto indices. sequant::Tensors with proto indices have
+/// outer and inner indices, whereas, those without proto indices only have
+/// outer indices.
 ///
-std::string indices_to_annot(InnerOuterIndices const& inout) noexcept;
+struct NestedTensorIndices {
+  container::svector<Index> outer, inner;
+
+  explicit NestedTensorIndices(Tensor const&);
+};
 
 ///
 /// \brief The EvalExpr class represents the object that go into the nodes of
@@ -181,26 +181,15 @@ class EvalExpr {
   [[nodiscard]] Variable const& as_variable() const noexcept;
 
   ///
-  /// \brief Separates indices of a tensor into inner and outer index groups.
-  ///
-  /// \details - If the expression this object holds is a Constant, then the
-  ///            resulting inner and outer indices are empty.
-  ///          - The outer indices are empty if neither of the indices in the
-  ///            tensor's braket have at least one proto-index.
-  ///          - The proto-indices are collected, sorted using
-  ///            Index::LabelCompare, and de-duplicated to form the outer
-  ///            indices.
-  ///          - The non-proto indices make up the inner indices if they are not
-  ///            already in the outer indices.
-  ///
-  /// \return InnerOuterIndices object.
+  /// \brief Get the label for this object useful for logging.
   ///
-  [[nodiscard]] InnerOuterIndices inner_outer_indices() const noexcept;
+  [[nodiscard]] std::string label() const noexcept;
 
   ///
-  /// \brief Get the label for this object useful for logging.
+  /// \return A string usable as TiledArray annotation if is_tensor() true,
+  ///         empty string otherwise.
   ///
-  [[nodiscard]] std::string label() const noexcept;
+  [[nodiscard]] std::string braket_annot() const noexcept;
 
  private:
   EvalOp op_type_;

SeQuant/core/eval_node.hpp

@@ -8,8 +8,8 @@
 #include <SeQuant/core/asy_cost.hpp>
 #include <SeQuant/core/binary_node.hpp>
 #include <SeQuant/core/eval_expr.hpp>
-#include <SeQuant/core/tensor.hpp>
 #include <SeQuant/core/math.hpp>
+#include <SeQuant/core/tensor.hpp>
 
 namespace sequant {
 

SeQuant/core/expr.cpp

@@ -2,13 +2,13 @@
 // Created by Eduard Valeyev on 2019-02-06.
 //
 
-#include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/abstract_tensor.hpp>
 #include <SeQuant/core/algorithm.hpp>
+#include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/logger.hpp>
 #include <SeQuant/core/tensor.hpp>
-#include <SeQuant/core/tensor_network.hpp>
 #include <SeQuant/core/tensor_canonicalizer.hpp>
+#include <SeQuant/core/tensor_network.hpp>
 
 #include <range/v3/all.hpp>
 

SeQuant/core/expr.hpp

@@ -40,7 +40,6 @@ namespace sequant {
 
 namespace {
 
-
 template <typename T>
 constexpr bool is_an_expr_v = meta::is_base_of_v<Expr, T>;
 template <typename T>
@@ -1684,7 +1683,6 @@ T &ExprPtr::as() {
 
 }  // namespace sequant
 
-
 #endif  // SEQUANT_EXPR_HPP
 
 #include "expr_operator.hpp"

SeQuant/core/index.cpp

@@ -2,8 +2,8 @@
 // Created by Eduard Valeyev on 4/30/20.
 //
 
-#include <SeQuant/core/index.hpp>
 #include <SeQuant/core/context.hpp>
+#include <SeQuant/core/index.hpp>
 #include <SeQuant/core/latex.hpp>
 #include <SeQuant/core/wstring.hpp>