Fix op_dag subtraction operators evaluating as addition

src/tamm/op_dag.hpp

@@ -493,7 +493,7 @@ AddOp operator+(LimitTo<Op, Op1>&& lhs, LimitTo<Op, Op2>&& rhs) {
 
 template<typename Op1, typename Op2>
 AddOp operator-(LimitTo<Op, Op1>&& lhs, LimitTo<Op, Op2>&& rhs) {
-  return {std::forward<Op1>(lhs), std::forward<Op2>(rhs)};
+  return {std::forward<Op1>(lhs), -1.0 * rhs};
 }
 
 template<typename T, typename Op1, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
@@ -508,12 +508,12 @@ AddOp operator+(T value, LimitTo<Op, Op1>&& rhs) {
 
 template<typename T, typename Op1, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
 AddOp operator-(LimitTo<Op, Op1>&& lhs, T value) {
-  return {std::forward<Op1>(lhs), Scalar{value}};
+  return {std::forward<Op1>(lhs), Scalar{-value}};
 }
 
 template<typename T, typename Op1, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
 AddOp operator-(T value, LimitTo<Op, Op1>&& rhs) {
-  return {Scalar{value}, std::forward<Op1>(rhs)};
+  return {Scalar{value}, -1.0 * rhs};
 }
 
 template<typename T, typename Op1, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>

tests/tamm/Test_OpDAG.cpp

@@ -955,6 +955,47 @@ void cs_ccsd_t1() {
   }
 }
 
+void test_sub_operator() {
+  using T = double;
+
+  ProcGroup        pg = ProcGroup::create_world_coll();
+  ExecutionContext ec{pg, DistributionKind::nw, MemoryManagerKind::ga};
+
+  TiledIndexSpace MO{IndexSpace{range(6)}, 2};
+  auto [i, j] = MO.labels<2>("all");
+  Tensor<T> A{i, j}, B{i, j}, R{i, j};
+
+  // Coefficient of the subtracted operand for each kind of rhs op
+  auto sub_rhs_coeff = [](auto&& op) { return op.rhs().coeff().template get<T>(); };
+  LTOp lt_b{B(i, j)};
+  EXPECTS(sub_rhs_coeff(LTOp{A(i, j)} - LTOp{B(i, j)}) == -1.0);
+  EXPECTS(sub_rhs_coeff(LTOp{A(i, j)} - lt_b) == -1.0);
+  EXPECTS(sub_rhs_coeff(LTOp{A(i, j)} - (2.0 * LTOp{B(i, j)})) == -2.0);
+  EXPECTS(sub_rhs_coeff(LTOp{A(i, j)} - (LTOp{A(i, j)} * LTOp{B(i, j)})) == -1.0);
+  EXPECTS(sub_rhs_coeff(LTOp{A(i, j)} + LTOp{B(i, j)}) == 1.0);
+
+  // End-to-end: R = A - B must evaluate to 3 - 1, not 3 + 1
+  Scheduler{ec}.allocate(A, B, R)(A(i, j) = 3.0)(B(i, j) = 1.0)(R(i, j) = 0.0).execute();
+
+  R(i, j).update(LTOp{A(i, j)} - LTOp{B(i, j)});
+
+  SymbolTable symbol_table;
+  TAMM_REGISTER_SYMBOLS(symbol_table, A, B, R);
+  TAMM_REGISTER_SYMBOLS(symbol_table, i, j);
+
+  Scheduler  sch{ec};
+  OpExecutor op_exec{sch, symbol_table};
+  op_exec.opmin_execute(R);
+
+  for(const auto& blockid: R.loop_nest()) {
+    std::vector<T> buf(R.block_size(blockid));
+    R.get(blockid, buf);
+    for(const auto& v: buf) EXPECTS(std::abs(v - 2.0) < 1e-10);
+  }
+
+  Tensor<T>::deallocate(A, B, R);
+}
+
 int main(int argc, char* argv[]) {
   tamm::initialize(argc, argv);
 
@@ -973,6 +1014,7 @@ int main(int argc, char* argv[]) {
   // test_new_ops();
   // test_utility_methods();
   // test_gfcc_failed_case();
+  test_sub_operator();
   cs_ccsd_t1<double>();
 
   tamm::finalize();

tests/tamm/test_tamm.cmake

@@ -11,7 +11,7 @@ add_mpi_unit_test(Test_DependentSpace 2 "")
 add_mpi_unit_test(Test_Utils 2 "")
 add_mpi_unit_test(Test_Mult_Ops 2 "50 20" )
 add_mpi_unit_test(Test_DLPNO_Ops 2 "10 2" )
-# add_mpi_unit_test(Test_OpDAG 2 "")
+add_mpi_unit_test(Test_OpDAG 2 "")
 add_mpi_unit_test(Test_Opmin 2 "")
 add_mpi_unit_test(Test_IO 2 "10 10" )
 add_mpi_unit_test(Test_EVP 2 "10 10" )