Deprecate Contracts->Contract

include/UniTensor.hpp

@@ -4454,6 +4454,22 @@ namespace cytnx {
 
   See also \link cytnx::UniTensor::contract UniTensor.contract \endlink
 
+  */
+  UniTensor Contract(const std::vector<UniTensor> &TNs, const std::string &order,
+                     const bool &optimal);
+
+  /**
+  @deprecated
+  @brief Contract multiple UniTensor by tracing the ranks with common labels with pairwise
+  operation.
+  @param[in] TNs the Tensors.
+  @param[in] order desired contraction order.
+  @param[in] optimal wheather to find the optimal contraction order automatically.
+  @return
+      [UniTensor]
+
+  See also \link cytnx::UniTensor::contract UniTensor.contract \endlink
+
   */
   UniTensor Contracts(const std::vector<UniTensor> &TNs, const std::string &order,
                       const bool &optimal);
@@ -4477,6 +4493,26 @@ namespace cytnx {
 
   See also \link cytnx::UniTensor::contract UniTensor.contract \endlink
 
+  */
+  template <class... T>
+  UniTensor Contract(const UniTensor &in, const T &...args, const std::string &order,
+                     const bool &optimal) {
+    std::vector<UniTensor> TNlist;
+    _resolve_CT(TNlist, in, args...);
+    return Contract(TNlist, order, optimal);
+  }
+
+  /**
+  @deprecated
+  @brief Contract multiple UniTensor by tracing the ranks with common labels with pairwise
+  operation.
+  @param in the Tensors.
+  @param args the Tensors.
+  @return
+      [UniTensor]
+
+  See also \link cytnx::UniTensor::contract UniTensor.contract \endlink
+
   */
   template <class... T>
   UniTensor Contracts(const UniTensor &in, const T &...args, const std::string &order,

pybind/unitensor_py.cpp

@@ -1372,8 +1372,18 @@ void unitensor_binding(py::module &m) {
      .def("get_qindices",  [](UniTensor &self, const cytnx_uint64 &bidx){return self.get_qindices(bidx);});
   ;  // end of object line
 
-  m.def("Contract", Contract, py::arg("Tl"), py::arg("Tr"), py::arg("cacheL") = false,
-        py::arg("cacheR") = false);
+  //   m.def("Contract", Contract, py::arg("Tl"), py::arg("Tr"), py::arg("cacheL") = false,
+  //         py::arg("cacheR") = false);
+  m.def(
+    "Contract",
+    [](const UniTensor &inL, const UniTensor &inR, const bool &cacheL,
+       const bool &cacheR) -> UniTensor { return Contract(inL, inR, cacheL, cacheR); },
+    py::arg("Tl"), py::arg("Tr"), py::arg("cacheL") = false, py::arg("cacheR") = false);
+  m.def(
+    "Contract",
+    [](const std::vector<UniTensor> &TNs, const std::string &order,
+       const bool &optimal) -> UniTensor { return Contract(TNs, order, optimal); },
+    py::arg("TNs"), py::arg("order") = "", py::arg("optimal") = true);
   m.def(
     "Contracts",
     [](const std::vector<UniTensor> &TNs, const std::string &order,

src/UniTensor_base.cpp

@@ -590,6 +590,10 @@ namespace cytnx {
   }
 
   void _resolve_CT(std::vector<UniTensor> &TNlist){};
+  UniTensor Contract(const std::vector<UniTensor> &TNs, const std::string &order = "",
+                     const bool &optimal = true) {
+    return Contracts(TNs, order, optimal);
+  }
   UniTensor Contracts(const std::vector<UniTensor> &TNs, const std::string &order = "",
                       const bool &optimal = true) {
     cytnx_error_msg(TNs.size() < 2, "[ERROR][Contracts] should have more than 2 TNs to contract.%s",

tests/CMakeLists.txt

@@ -11,7 +11,7 @@ add_executable(
   Network_test.cpp
   UniTensor_base_test.cpp
   ncon_test.cpp
-  Contracts_test.cpp
+  Contract_test.cpp
   BlockUniTensor_test.cpp
   DenseUniTensor_test.cpp
   Accessor_test.cpp

tests/Contract_test.cpp

@@ -0,0 +1,49 @@
+#include "Contract_test.h"
+
+using namespace std;
+using namespace cytnx;
+
+TEST_F(ContractTest, Contract_denseUt_optimal_order) {
+  UniTensor res = Contract({utdnA, utdnB, utdnC}, "", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, Contract_denseUt_default_order) {
+  UniTensor res = Contract({utdnA, utdnB, utdnC}, "", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, Contract_denseUt_specified_order) {
+  UniTensor res =
+    Contract({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, Contract_denseUt_optimal_specified_order) {
+  UniTensor res =
+    Contract({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}
+
+// Deprecated Contracts
+TEST_F(ContractTest, Contracts_denseUt_optimal_order) {
+  UniTensor res = Contracts({utdnA, utdnB, utdnC}, "", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, Contracts_denseUt_default_order) {
+  UniTensor res = Contracts({utdnA, utdnB, utdnC}, "", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, Contracts_denseUt_specified_order) {
+  UniTensor res =
+    Contracts({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, Contracts_denseUt_optimal_specified_order) {
+  UniTensor res =
+    Contracts({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}

tests/Contracts_test.h → tests/Contract_test.h

@@ -1,5 +1,5 @@
-#ifndef _H_contracts_test
-#define _H_contracts_test
+#ifndef _H_contract_test
+#define _H_contract_test
 
 #include "cytnx.hpp"
 #include <gtest/gtest.h>
@@ -8,7 +8,7 @@
 using namespace cytnx;
 using namespace TestTools;
 
-class ContractsTest : public ::testing::Test {
+class ContractTest : public ::testing::Test {
  public:
   // std::pair<std::vector<cytnx::UniTensor>, std::vector<std::vector<cytnx::cytnx_int64>>> input;
   UniTensor utdnA = UniTensor(arange(0, 8, 1, Type.ComplexDouble)).reshape({2, 2, 2});

tests/gpu/CMakeLists.txt

@@ -6,7 +6,7 @@ add_executable(
   Network_test.cpp
   UniTensor_base_test.cpp
   ncon_test.cpp
-  Contracts_test.cpp
+  Contract_test.cpp
   BlockUniTensor_test.cpp
   DenseUniTensor_test.cpp
   Accessor_test.cpp

tests/gpu/Contract_test.cpp

@@ -0,0 +1,49 @@
+#include "Contract_test.h"
+
+using namespace std;
+using namespace cytnx;
+
+TEST_F(ContractTest, gpu_Contract_denseUt_optimal_order) {
+  UniTensor res = Contract({utdnA, utdnB, utdnC}, "", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, gpu_Contract_denseUt_default_order) {
+  UniTensor res = Contract({utdnA, utdnB, utdnC}, "", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, gpu_Contract_denseUt_specified_order) {
+  UniTensor res =
+    Contract({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, gpu_Contract_denseUt_optimal_specified_order) {
+  UniTensor res =
+    Contract({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}
+
+// Deprecated Contracts
+TEST_F(ContractTest, gpu_Contracts_denseUt_optimal_order) {
+  UniTensor res = Contracts({utdnA, utdnB, utdnC}, "", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, gpu_Contracts_denseUt_default_order) {
+  UniTensor res = Contracts({utdnA, utdnB, utdnC}, "", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, gpu_Contracts_denseUt_specified_order) {
+  UniTensor res =
+    Contracts({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", false);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}
+
+TEST_F(ContractTest, gpu_Contracts_denseUt_optimal_specified_order) {
+  UniTensor res =
+    Contracts({utdnA.set_name("A"), utdnB.set_name("B"), utdnC.set_name("C")}, "(C,(A,B))", true);
+  EXPECT_TRUE(AreNearlyEqTensor(res.get_block().contiguous(), utdnAns.get_block(), 1e-12));
+}

tests/gpu/Contracts_test.h → tests/gpu/Contract_test.h

@@ -1,5 +1,5 @@
-#ifndef _H_contracts_test
-#define _H_contracts_test
+#ifndef _H_contract_test
+#define _H_contract_test
 
 #include "cytnx.hpp"
 #include <gtest/gtest.h>
@@ -8,7 +8,7 @@
 using namespace cytnx;
 using namespace TestTools;
 
-class ContractsTest : public ::testing::Test {
+class ContractTest : public ::testing::Test {
  public:
   // std::pair<std::vector<cytnx::UniTensor>, std::vector<std::vector<cytnx::cytnx_int64>>> input;
   UniTensor utdnA =